appwrite 25.1.0 → 26.1.0

data/lib/appwrite/models/block.rb

@@ -6,6 +6,7 @@ module Appwrite
             attr_reader :created_at
             attr_reader :resource_type
             attr_reader :resource_id
+            attr_reader :mode
             attr_reader :reason
             attr_reader :expired_at
             attr_reader :project_name
@@ -18,6 +19,7 @@ module Appwrite
                 created_at:,
                 resource_type:,
                 resource_id:,
+                mode:,
                 reason: ,
                 expired_at: ,
                 project_name:,
@@ -29,6 +31,7 @@ module Appwrite
                 @created_at = created_at
                 @resource_type = resource_type
                 @resource_id = resource_id
+                @mode = mode
                 @reason = reason
                 @expired_at = expired_at
                 @project_name = project_name
@@ -43,6 +46,7 @@ module Appwrite
                     created_at: map["$createdAt"],
                     resource_type: map["resourceType"],
                     resource_id: map["resourceId"],
+                    mode: map["mode"],
                     reason: map["reason"],
                     expired_at: map["expiredAt"],
                     project_name: map["projectName"],
@@ -58,6 +62,7 @@ module Appwrite
                     "$createdAt": @created_at,
                     "resourceType": @resource_type,
                     "resourceId": @resource_id,
+                    "mode": @mode,
                     "reason": @reason,
                     "expiredAt": @expired_at,
                     "projectName": @project_name,

data/lib/appwrite/models/database.rb

@@ -9,6 +9,10 @@ module Appwrite
             attr_reader :updated_at
             attr_reader :enabled
             attr_reader :type
+            attr_reader :status
+            attr_reader :engine
+            attr_reader :specification
+            attr_reader :replicas
             attr_reader :policies
             attr_reader :archives
 
@@ -19,8 +23,12 @@ module Appwrite
                 updated_at:,
                 enabled:,
                 type:,
-                policies:,
-                archives:
+                status: ,
+                engine: ,
+                specification: ,
+                replicas: ,
+                policies: ,
+                archives: 
             )
                 @id = id
                 @name = name
@@ -28,6 +36,10 @@ module Appwrite
                 @updated_at = updated_at
                 @enabled = enabled
                 @type = validate_type(type)
+                @status = status.nil? ? status : validate_status(status)
+                @engine = engine
+                @specification = specification
+                @replicas = replicas
                 @policies = policies
                 @archives = archives
             end
@@ -40,8 +52,12 @@ module Appwrite
                     updated_at: map["$updatedAt"],
                     enabled: map["enabled"],
                     type: map["type"],
-                    policies: map["policies"].map { |it| BackupPolicy.from(map: it) },
-                    archives: map["archives"].map { |it| BackupArchive.from(map: it) }
+                    status: map["status"],
+                    engine: map["engine"],
+                    specification: map["specification"],
+                    replicas: map["replicas"],
+                    policies: map["policies"]&.map { |it| BackupPolicy.from(map: it) },
+                    archives: map["archives"]&.map { |it| BackupArchive.from(map: it) }
                 )
             end
 
@@ -53,8 +69,12 @@ module Appwrite
                     "$updatedAt": @updated_at,
                     "enabled": @enabled,
                     "type": @type,
-                    "policies": @policies.map { |it| it.to_map },
-                    "archives": @archives.map { |it| it.to_map }
+                    "status": @status,
+                    "engine": @engine,
+                    "specification": @specification,
+                    "replicas": @replicas,
+                    "policies": @policies&.map { |it| it.to_map },
+                    "archives": @archives&.map { |it| it.to_map }
                 }
             end
 
@@ -66,6 +86,9 @@ module Appwrite
                     Appwrite::Enums::DatabaseType::TABLESDB,
                     Appwrite::Enums::DatabaseType::DOCUMENTSDB,
                     Appwrite::Enums::DatabaseType::VECTORSDB,
+                    Appwrite::Enums::DatabaseType::MYSQL,
+                    Appwrite::Enums::DatabaseType::POSTGRESQL,
+                    Appwrite::Enums::DatabaseType::MONGODB,
                 ]
 
                 unless valid_type.include?(type)
@@ -75,6 +98,31 @@ module Appwrite
                 type
             end
 
+            def validate_status(status)
+                valid_status = [
+                    Appwrite::Enums::DatabaseStatus::PROVISIONING,
+                    Appwrite::Enums::DatabaseStatus::READY,
+                    Appwrite::Enums::DatabaseStatus::INACTIVE,
+                    Appwrite::Enums::DatabaseStatus::PAUSED,
+                    Appwrite::Enums::DatabaseStatus::FAILED,
+                    Appwrite::Enums::DatabaseStatus::DELETING,
+                    Appwrite::Enums::DatabaseStatus::DELETED,
+                    Appwrite::Enums::DatabaseStatus::RESTORING,
+                    Appwrite::Enums::DatabaseStatus::SCALING,
+                    Appwrite::Enums::DatabaseStatus::UPGRADING,
+                    Appwrite::Enums::DatabaseStatus::MIGRATING,
+                    Appwrite::Enums::DatabaseStatus::PAUSING,
+                    Appwrite::Enums::DatabaseStatus::RESUMING,
+                    Appwrite::Enums::DatabaseStatus::FAILING_OVER,
+                ]
+
+                unless valid_status.include?(status)
+                    raise ArgumentError, "Invalid " + status + ". Must be one of: " + valid_status.join(', ')
+                end
+
+                status
+            end
+
         end
     end
 end

data/lib/appwrite/models/database_status.rb

@@ -0,0 +1,62 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DatabaseStatus
+            attr_reader :health
+            attr_reader :ready
+            attr_reader :engine
+            attr_reader :version
+            attr_reader :uptime
+            attr_reader :connections
+            attr_reader :replicas
+            attr_reader :volumes
+
+            def initialize(
+                health:,
+                ready:,
+                engine:,
+                version:,
+                uptime:,
+                connections:,
+                replicas:,
+                volumes:
+            )
+                @health = health
+                @ready = ready
+                @engine = engine
+                @version = version
+                @uptime = uptime
+                @connections = connections
+                @replicas = replicas
+                @volumes = volumes
+            end
+
+            def self.from(map:)
+                DatabaseStatus.new(
+                    health: map["health"],
+                    ready: map["ready"],
+                    engine: map["engine"],
+                    version: map["version"],
+                    uptime: map["uptime"],
+                    connections: DatabaseStatusConnections.from(map: map["connections"]),
+                    replicas: map["replicas"].map { |it| DatabaseStatusReplica.from(map: it) },
+                    volumes: map["volumes"].map { |it| DatabaseStatusVolume.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "health": @health,
+                    "ready": @ready,
+                    "engine": @engine,
+                    "version": @version,
+                    "uptime": @uptime,
+                    "connections": @connections.to_map,
+                    "replicas": @replicas.map { |it| it.to_map },
+                    "volumes": @volumes.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/database_status_connections.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DatabaseStatusConnections
+            attr_reader :current
+            attr_reader :max
+
+            def initialize(
+                current:,
+                max:
+            )
+                @current = current
+                @max = max
+            end
+
+            def self.from(map:)
+                DatabaseStatusConnections.new(
+                    current: map["current"],
+                    max: map["max"]
+                )
+            end
+
+            def to_map
+                {
+                    "current": @current,
+                    "max": @max
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/database_status_replica.rb

@@ -0,0 +1,42 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DatabaseStatusReplica
+            attr_reader :index
+            attr_reader :role
+            attr_reader :healthy
+            attr_reader :lag_seconds
+
+            def initialize(
+                index:,
+                role:,
+                healthy:,
+                lag_seconds: 
+            )
+                @index = index
+                @role = role
+                @healthy = healthy
+                @lag_seconds = lag_seconds
+            end
+
+            def self.from(map:)
+                DatabaseStatusReplica.new(
+                    index: map["index"],
+                    role: map["role"],
+                    healthy: map["healthy"],
+                    lag_seconds: map["lagSeconds"]
+                )
+            end
+
+            def to_map
+                {
+                    "index": @index,
+                    "role": @role,
+                    "healthy": @healthy,
+                    "lagSeconds": @lag_seconds
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/database_status_volume.rb

@@ -0,0 +1,42 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DatabaseStatusVolume
+            attr_reader :xpath
+            attr_reader :used_percent
+            attr_reader :available
+            attr_reader :mounted
+
+            def initialize(
+                xpath:,
+                used_percent:,
+                available:,
+                mounted:
+            )
+                @xpath = xpath
+                @used_percent = used_percent
+                @available = available
+                @mounted = mounted
+            end
+
+            def self.from(map:)
+                DatabaseStatusVolume.new(
+                    xpath: map["path"],
+                    used_percent: map["usedPercent"],
+                    available: map["available"],
+                    mounted: map["mounted"]
+                )
+            end
+
+            def to_map
+                {
+                    "path": @xpath,
+                    "usedPercent": @used_percent,
+                    "available": @available,
+                    "mounted": @mounted
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database.rb

@@ -0,0 +1,267 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabase
+            attr_reader :id
+            attr_reader :created_at
+            attr_reader :updated_at
+            attr_reader :project_id
+            attr_reader :name
+            attr_reader :api
+            attr_reader :engine
+            attr_reader :version
+            attr_reader :specification
+            attr_reader :backend
+            attr_reader :hostname
+            attr_reader :connection_port
+            attr_reader :connection_user
+            attr_reader :connection_password
+            attr_reader :connection_string
+            attr_reader :ssl
+            attr_reader :status
+            attr_reader :container_status
+            attr_reader :last_accessed_at
+            attr_reader :idle_until
+            attr_reader :lifecycle_state
+            attr_reader :idle_timeout_minutes
+            attr_reader :cpu
+            attr_reader :memory
+            attr_reader :storage
+            attr_reader :storage_class
+            attr_reader :storage_max_gb
+            attr_reader :node_pool
+            attr_reader :replicas
+            attr_reader :sync_mode
+            attr_reader :cross_region_replicas
+            attr_reader :network_max_connections
+            attr_reader :network_idle_timeout_seconds
+            attr_reader :network_ip_allowlist
+            attr_reader :backup_enabled
+            attr_reader :pitr
+            attr_reader :pitr_retention_days
+            attr_reader :storage_autoscaling
+            attr_reader :storage_autoscaling_threshold_percent
+            attr_reader :storage_autoscaling_max_gb
+            attr_reader :maintenance_window_day
+            attr_reader :maintenance_window_hour_utc
+            attr_reader :metrics_enabled
+            attr_reader :sql_api_enabled
+            attr_reader :sql_api_allowed_statements
+            attr_reader :sql_api_max_rows
+            attr_reader :sql_api_max_bytes
+            attr_reader :sql_api_timeout_seconds
+            attr_reader :error
+
+            def initialize(
+                id:,
+                created_at:,
+                updated_at:,
+                project_id:,
+                name:,
+                api:,
+                engine:,
+                version:,
+                specification:,
+                backend:,
+                hostname:,
+                connection_port:,
+                connection_user:,
+                connection_password:,
+                connection_string:,
+                ssl:,
+                status:,
+                container_status:,
+                last_accessed_at: ,
+                idle_until: ,
+                lifecycle_state:,
+                idle_timeout_minutes:,
+                cpu:,
+                memory:,
+                storage:,
+                storage_class:,
+                storage_max_gb:,
+                node_pool:,
+                replicas:,
+                sync_mode:,
+                cross_region_replicas:,
+                network_max_connections:,
+                network_idle_timeout_seconds:,
+                network_ip_allowlist:,
+                backup_enabled:,
+                pitr:,
+                pitr_retention_days:,
+                storage_autoscaling:,
+                storage_autoscaling_threshold_percent:,
+                storage_autoscaling_max_gb:,
+                maintenance_window_day:,
+                maintenance_window_hour_utc:,
+                metrics_enabled:,
+                sql_api_enabled:,
+                sql_api_allowed_statements:,
+                sql_api_max_rows:,
+                sql_api_max_bytes:,
+                sql_api_timeout_seconds:,
+                error:
+            )
+                @id = id
+                @created_at = created_at
+                @updated_at = updated_at
+                @project_id = project_id
+                @name = name
+                @api = api
+                @engine = engine
+                @version = version
+                @specification = specification
+                @backend = backend
+                @hostname = hostname
+                @connection_port = connection_port
+                @connection_user = connection_user
+                @connection_password = connection_password
+                @connection_string = connection_string
+                @ssl = ssl
+                @status = status
+                @container_status = container_status
+                @last_accessed_at = last_accessed_at
+                @idle_until = idle_until
+                @lifecycle_state = lifecycle_state
+                @idle_timeout_minutes = idle_timeout_minutes
+                @cpu = cpu
+                @memory = memory
+                @storage = storage
+                @storage_class = storage_class
+                @storage_max_gb = storage_max_gb
+                @node_pool = node_pool
+                @replicas = replicas
+                @sync_mode = sync_mode
+                @cross_region_replicas = cross_region_replicas
+                @network_max_connections = network_max_connections
+                @network_idle_timeout_seconds = network_idle_timeout_seconds
+                @network_ip_allowlist = network_ip_allowlist
+                @backup_enabled = backup_enabled
+                @pitr = pitr
+                @pitr_retention_days = pitr_retention_days
+                @storage_autoscaling = storage_autoscaling
+                @storage_autoscaling_threshold_percent = storage_autoscaling_threshold_percent
+                @storage_autoscaling_max_gb = storage_autoscaling_max_gb
+                @maintenance_window_day = maintenance_window_day
+                @maintenance_window_hour_utc = maintenance_window_hour_utc
+                @metrics_enabled = metrics_enabled
+                @sql_api_enabled = sql_api_enabled
+                @sql_api_allowed_statements = sql_api_allowed_statements
+                @sql_api_max_rows = sql_api_max_rows
+                @sql_api_max_bytes = sql_api_max_bytes
+                @sql_api_timeout_seconds = sql_api_timeout_seconds
+                @error = error
+            end
+
+            def self.from(map:)
+                DedicatedDatabase.new(
+                    id: map["$id"],
+                    created_at: map["$createdAt"],
+                    updated_at: map["$updatedAt"],
+                    project_id: map["projectId"],
+                    name: map["name"],
+                    api: map["api"],
+                    engine: map["engine"],
+                    version: map["version"],
+                    specification: map["specification"],
+                    backend: map["backend"],
+                    hostname: map["hostname"],
+                    connection_port: map["connectionPort"],
+                    connection_user: map["connectionUser"],
+                    connection_password: map["connectionPassword"],
+                    connection_string: map["connectionString"],
+                    ssl: map["ssl"],
+                    status: map["status"],
+                    container_status: map["containerStatus"],
+                    last_accessed_at: map["lastAccessedAt"],
+                    idle_until: map["idleUntil"],
+                    lifecycle_state: map["lifecycleState"],
+                    idle_timeout_minutes: map["idleTimeoutMinutes"],
+                    cpu: map["cpu"],
+                    memory: map["memory"],
+                    storage: map["storage"],
+                    storage_class: map["storageClass"],
+                    storage_max_gb: map["storageMaxGb"],
+                    node_pool: map["nodePool"],
+                    replicas: map["replicas"],
+                    sync_mode: map["syncMode"],
+                    cross_region_replicas: map["crossRegionReplicas"],
+                    network_max_connections: map["networkMaxConnections"],
+                    network_idle_timeout_seconds: map["networkIdleTimeoutSeconds"],
+                    network_ip_allowlist: map["networkIPAllowlist"],
+                    backup_enabled: map["backupEnabled"],
+                    pitr: map["pitr"],
+                    pitr_retention_days: map["pitrRetentionDays"],
+                    storage_autoscaling: map["storageAutoscaling"],
+                    storage_autoscaling_threshold_percent: map["storageAutoscalingThresholdPercent"],
+                    storage_autoscaling_max_gb: map["storageAutoscalingMaxGb"],
+                    maintenance_window_day: map["maintenanceWindowDay"],
+                    maintenance_window_hour_utc: map["maintenanceWindowHourUtc"],
+                    metrics_enabled: map["metricsEnabled"],
+                    sql_api_enabled: map["sqlApiEnabled"],
+                    sql_api_allowed_statements: map["sqlApiAllowedStatements"],
+                    sql_api_max_rows: map["sqlApiMaxRows"],
+                    sql_api_max_bytes: map["sqlApiMaxBytes"],
+                    sql_api_timeout_seconds: map["sqlApiTimeoutSeconds"],
+                    error: map["error"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$createdAt": @created_at,
+                    "$updatedAt": @updated_at,
+                    "projectId": @project_id,
+                    "name": @name,
+                    "api": @api,
+                    "engine": @engine,
+                    "version": @version,
+                    "specification": @specification,
+                    "backend": @backend,
+                    "hostname": @hostname,
+                    "connectionPort": @connection_port,
+                    "connectionUser": @connection_user,
+                    "connectionPassword": @connection_password,
+                    "connectionString": @connection_string,
+                    "ssl": @ssl,
+                    "status": @status,
+                    "containerStatus": @container_status,
+                    "lastAccessedAt": @last_accessed_at,
+                    "idleUntil": @idle_until,
+                    "lifecycleState": @lifecycle_state,
+                    "idleTimeoutMinutes": @idle_timeout_minutes,
+                    "cpu": @cpu,
+                    "memory": @memory,
+                    "storage": @storage,
+                    "storageClass": @storage_class,
+                    "storageMaxGb": @storage_max_gb,
+                    "nodePool": @node_pool,
+                    "replicas": @replicas,
+                    "syncMode": @sync_mode,
+                    "crossRegionReplicas": @cross_region_replicas,
+                    "networkMaxConnections": @network_max_connections,
+                    "networkIdleTimeoutSeconds": @network_idle_timeout_seconds,
+                    "networkIPAllowlist": @network_ip_allowlist,
+                    "backupEnabled": @backup_enabled,
+                    "pitr": @pitr,
+                    "pitrRetentionDays": @pitr_retention_days,
+                    "storageAutoscaling": @storage_autoscaling,
+                    "storageAutoscalingThresholdPercent": @storage_autoscaling_threshold_percent,
+                    "storageAutoscalingMaxGb": @storage_autoscaling_max_gb,
+                    "maintenanceWindowDay": @maintenance_window_day,
+                    "maintenanceWindowHourUtc": @maintenance_window_hour_utc,
+                    "metricsEnabled": @metrics_enabled,
+                    "sqlApiEnabled": @sql_api_enabled,
+                    "sqlApiAllowedStatements": @sql_api_allowed_statements,
+                    "sqlApiMaxRows": @sql_api_max_rows,
+                    "sqlApiMaxBytes": @sql_api_max_bytes,
+                    "sqlApiTimeoutSeconds": @sql_api_timeout_seconds,
+                    "error": @error
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database_member.rb

@@ -0,0 +1,42 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabaseMember
+            attr_reader :id
+            attr_reader :role
+            attr_reader :status
+            attr_reader :lag_seconds
+
+            def initialize(
+                id:,
+                role:,
+                status:,
+                lag_seconds:
+            )
+                @id = id
+                @role = role
+                @status = status
+                @lag_seconds = lag_seconds
+            end
+
+            def self.from(map:)
+                DedicatedDatabaseMember.new(
+                    id: map["$id"],
+                    role: map["role"],
+                    status: map["status"],
+                    lag_seconds: map["lagSeconds"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "role": @role,
+                    "status": @status,
+                    "lagSeconds": @lag_seconds
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/dedicated_database_replicas.rb

@@ -0,0 +1,37 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DedicatedDatabaseReplicas
+            attr_reader :replicas
+            attr_reader :sync_mode
+            attr_reader :members
+
+            def initialize(
+                replicas:,
+                sync_mode:,
+                members:
+            )
+                @replicas = replicas
+                @sync_mode = sync_mode
+                @members = members
+            end
+
+            def self.from(map:)
+                DedicatedDatabaseReplicas.new(
+                    replicas: map["replicas"],
+                    sync_mode: map["syncMode"],
+                    members: map["members"].map { |it| DedicatedDatabaseMember.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "replicas": @replicas,
+                    "syncMode": @sync_mode,
+                    "members": @members.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end