appwrite 4.1.0 → 7.0.0.pre.RC1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ccc9454e05eee3806e9bcb29e95ef8202b0fc617215e837e52a2cff52199bfd
-  data.tar.gz: 739353c7c628f0711f3c466c3d35f6db829bec9362415a735cf9ac3b72273a41
+  metadata.gz: 01f7539c1b2b2cf555a208ea8d780fb9acac96bc82925a6f1f04b4531a9955c0
+  data.tar.gz: 46cd30c3ac91258db353b6f59f912bc291e86f52a69e2e328f01328c05ec0e6f
 SHA512:
-  metadata.gz: 483f458ce6e1b4abdeaeb96e60fabeb4f778fe775e39a1999abf19725f461a2db190b8b2b31f15d32d838436ac8b0e58bf6f1ce4f183e4a019d4fab75f0e8773
-  data.tar.gz: 91b5993ca7e9186e65150daf278751a510155d2d15a0de54169d9b6efdee376b93a99f512f75a649b32e04a389fe9ca8224e144c6905ccca4b11639930995478
+  metadata.gz: 16b84a186ee035ee618243fb8fd908c1985e6f2cf6c9a87ac0fd31904c8a30004e616d8568c0e367db6fd701f1542198dd1a1b7583cb400de9947a51889e559e
+  data.tar.gz: 0ec0f97ebe6aa21a9a0d4374a41432b820ba23b07d785c231a615b731775cc4e46f342f88c5897e9f99e09602a98a81772d0d84ea533c3aa251e3be8165d834c

data/lib/appwrite/client.rb

@@ -12,8 +12,11 @@ module Appwrite
             @chunk_size = 5*1024*1024
             @headers = {
                 'user-agent' => RUBY_PLATFORM + ':ruby-' + RUBY_VERSION,
-                'x-sdk-version' => 'appwrite:ruby:4.1.0',                
-                'X-Appwrite-Response-Format' => '0.13.0'
+                'x-sdk-name'=> 'Ruby',
+                'x-sdk-platform'=> 'server',
+                'x-sdk-language'=> 'ruby',
+                'x-sdk-version'=> '7.0.0-RC1',                
+                'X-Appwrite-Response-Format' => '1.0.0-RC1'
             }
             @endpoint = 'https://HOSTNAME/v1'
         end
@@ -133,12 +136,20 @@ module Appwrite
             on_progress: nil,
             response_type: nil
         )
-            file_path = params[param_name.to_sym]
-            size = ::File.size(file_path)
+            input_file = params[param_name.to_sym]
+
+            case input_file.source_type
+            when 'path'
+                size = ::File.size(input_file.path)
+            when 'string'
+                size = input_file.data.bytesize
+            end
 
             if size < @chunk_size
-                slice = ::File.read(file_path)
-                params[param_name] = File.new(file_path, slice)
+                if input_file.source_type == 'path'
+                    input_file.data = IO.read(input_file.path)
+                end
+                params[param_name.to_sym] = input_file
                 return call(
                     method: 'POST',
                     path: path,
@@ -163,9 +174,19 @@ module Appwrite
             end
 
             while offset < size
-                slice = IO.read(file_path, @chunk_size, offset)
+                case input_file.source_type
+                when 'path'
+                    string = IO.read(input_file.path, @chunk_size, offset)
+                when 'string'
+                    string = input_file.data.byteslice(offset, [@chunk_size, size - offset].min)
+                end
+
+                params[param_name.to_sym] = InputFile::from_string(
+                    string,
+                    filename: input_file.filename,
+                    mime_type: input_file.mime_type
+                )
 
-                params[param_name] = File.new(file_path, slice)
                 headers['content-range'] = "bytes #{offset}-#{[offset + @chunk_size - 1, size].min}/#{size}"
 
                 result = call(
@@ -279,10 +300,10 @@ module Appwrite
                 ''
             else
                 post_body = []
-                if value.instance_of? File
-                    post_body << "Content-Disposition: form-data; name=\"#{key}\"; filename=\"#{value.name}\"\r\n"
+                if value.instance_of? InputFile
+                    post_body << "Content-Disposition: form-data; name=\"#{key}\"; filename=\"#{value.filename}\"\r\n"
                     post_body << "Content-Type: #{value.mime_type}\r\n\r\n"
-                    post_body << value.content
+                    post_body << value.data
                     post_body << "\r\n--#{@boundary}--\r\n"
                 else          
                     post_body << "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n"

data/lib/appwrite/id.rb

@@ -0,0 +1,11 @@
+module Appwrite
+    class ID
+        def self.custom(id)
+            id
+        end
+        
+        def self.unique
+            'unique()'
+        end
+    end
+end

data/lib/appwrite/input_file.rb

@@ -0,0 +1,33 @@
+require 'mime/types'
+
+module Appwrite
+    class InputFile
+        attr_accessor :path
+        attr_accessor :filename
+        attr_accessor :mime_type
+        attr_accessor :source_type
+        attr_accessor :data
+
+        def self.from_path(path)
+            instance = InputFile.new
+            instance.path = path
+            instance.filename = ::File.basename(path)
+            instance.mime_type = MIME::Types.type_for(path).first.content_type
+            instance.source_type = 'path'
+            instance
+        end
+
+        def self.from_string(string, filename: nil, mime_type: nil)
+            instance = InputFile.new
+            instance.data = string
+            instance.filename = filename
+            instance.mime_type = mime_type
+            instance.source_type = 'string'
+            instance
+        end
+
+        def self.from_bytes(bytes, filename: nil, mime_type: nil)
+            self.from_string(bytes.pack('C*'), filename: filename, mime_type: mime_type)
+        end
+    end
+end

data/lib/appwrite/models/account.rb

@@ -0,0 +1,82 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Account
+            attr_reader :id
+            attr_reader :created_at
+            attr_reader :updated_at
+            attr_reader :name
+            attr_reader :registration
+            attr_reader :status
+            attr_reader :password_update
+            attr_reader :email
+            attr_reader :phone
+            attr_reader :email_verification
+            attr_reader :phone_verification
+            attr_reader :prefs
+
+            def initialize(
+                id:,
+                created_at:,
+                updated_at:,
+                name:,
+                registration:,
+                status:,
+                password_update:,
+                email:,
+                phone:,
+                email_verification:,
+                phone_verification:,
+                prefs:
+            )
+                @id = id
+                @created_at = created_at
+                @updated_at = updated_at
+                @name = name
+                @registration = registration
+                @status = status
+                @password_update = password_update
+                @email = email
+                @phone = phone
+                @email_verification = email_verification
+                @phone_verification = phone_verification
+                @prefs = prefs
+            end
+
+            def self.from(map:)
+                Account.new(
+                    id: map["$id"],
+                    created_at: map["$createdAt"],
+                    updated_at: map["$updatedAt"],
+                    name: map["name"],
+                    registration: map["registration"],
+                    status: map["status"],
+                    password_update: map["passwordUpdate"],
+                    email: map["email"],
+                    phone: map["phone"],
+                    email_verification: map["emailVerification"],
+                    phone_verification: map["phoneVerification"],
+                    prefs: Preferences.from(map: map["prefs"])
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$createdAt": @created_at,
+                    "$updatedAt": @updated_at,
+                    "name": @name,
+                    "registration": @registration,
+                    "status": @status,
+                    "passwordUpdate": @password_update,
+                    "email": @email,
+                    "phone": @phone,
+                    "emailVerification": @email_verification,
+                    "phoneVerification": @phone_verification,
+                    "prefs": @prefs.to_map
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/algo_argon2.rb

@@ -0,0 +1,37 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class AlgoArgon2
+            attr_reader :memory_cost
+            attr_reader :time_cost
+            attr_reader :threads
+
+            def initialize(
+                memory_cost:,
+                time_cost:,
+                threads:
+            )
+                @memory_cost = memory_cost
+                @time_cost = time_cost
+                @threads = threads
+            end
+
+            def self.from(map:)
+                AlgoArgon2.new(
+                    memory_cost: map["memoryCost"],
+                    time_cost: map["timeCost"],
+                    threads: map["threads"]
+                )
+            end
+
+            def to_map
+                {
+                    "memoryCost": @memory_cost,
+                    "timeCost": @time_cost,
+                    "threads": @threads
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/algo_bcrypt.rb

@@ -0,0 +1,22 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class AlgoBcrypt
+
+            def initialize(
+            )
+            end
+
+            def self.from(map:)
+                AlgoBcrypt.new(
+                )
+            end
+
+            def to_map
+                {
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/algo_md5.rb

@@ -0,0 +1,22 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class AlgoMd5
+
+            def initialize(
+            )
+            end
+
+            def self.from(map:)
+                AlgoMd5.new(
+                )
+            end
+
+            def to_map
+                {
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/algo_phpass.rb

@@ -0,0 +1,22 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class AlgoPhpass
+
+            def initialize(
+            )
+            end
+
+            def self.from(map:)
+                AlgoPhpass.new(
+                )
+            end
+
+            def to_map
+                {
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/algo_scrypt.rb

@@ -0,0 +1,42 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class AlgoScrypt
+            attr_reader :cost_cpu
+            attr_reader :cost_memory
+            attr_reader :cost_parallel
+            attr_reader :length
+
+            def initialize(
+                cost_cpu:,
+                cost_memory:,
+                cost_parallel:,
+                length:
+            )
+                @cost_cpu = cost_cpu
+                @cost_memory = cost_memory
+                @cost_parallel = cost_parallel
+                @length = length
+            end
+
+            def self.from(map:)
+                AlgoScrypt.new(
+                    cost_cpu: map["costCpu"],
+                    cost_memory: map["costMemory"],
+                    cost_parallel: map["costParallel"],
+                    length: map["length"]
+                )
+            end
+
+            def to_map
+                {
+                    "costCpu": @cost_cpu,
+                    "costMemory": @cost_memory,
+                    "costParallel": @cost_parallel,
+                    "length": @length
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/algo_scrypt_modified.rb

@@ -0,0 +1,37 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class AlgoScryptModified
+            attr_reader :salt
+            attr_reader :salt_separator
+            attr_reader :signer_key
+
+            def initialize(
+                salt:,
+                salt_separator:,
+                signer_key:
+            )
+                @salt = salt
+                @salt_separator = salt_separator
+                @signer_key = signer_key
+            end
+
+            def self.from(map:)
+                AlgoScryptModified.new(
+                    salt: map["salt"],
+                    salt_separator: map["saltSeparator"],
+                    signer_key: map["signerKey"]
+                )
+            end
+
+            def to_map
+                {
+                    "salt": @salt,
+                    "saltSeparator": @salt_separator,
+                    "signerKey": @signer_key
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/algo_sha.rb

@@ -0,0 +1,22 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class AlgoSha
+
+            def initialize(
+            )
+            end
+
+            def self.from(map:)
+                AlgoSha.new(
+                )
+            end
+
+            def to_map
+                {
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/attribute_datetime.rb

@@ -0,0 +1,57 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class AttributeDatetime
+            attr_reader :key
+            attr_reader :type
+            attr_reader :status
+            attr_reader :required
+            attr_reader :array
+            attr_reader :format
+            attr_reader :default
+
+            def initialize(
+                key:,
+                type:,
+                status:,
+                required:,
+                array: ,
+                format:,
+                default: 
+            )
+                @key = key
+                @type = type
+                @status = status
+                @required = required
+                @array = array
+                @format = format
+                @default = default
+            end
+
+            def self.from(map:)
+                AttributeDatetime.new(
+                    key: map["key"],
+                    type: map["type"],
+                    status: map["status"],
+                    required: map["required"],
+                    array: map["array"],
+                    format: map["format"],
+                    default: map["default"]
+                )
+            end
+
+            def to_map
+                {
+                    "key": @key,
+                    "type": @type,
+                    "status": @status,
+                    "required": @required,
+                    "array": @array,
+                    "format": @format,
+                    "default": @default
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/bucket.rb

@@ -4,42 +4,42 @@ module Appwrite
     module Models
         class Bucket
             attr_reader :id
-            attr_reader :read
-            attr_reader :write
-            attr_reader :permission
-            attr_reader :date_created
-            attr_reader :date_updated
+            attr_reader :created_at
+            attr_reader :updated_at
+            attr_reader :permissions
+            attr_reader :file_security
             attr_reader :name
             attr_reader :enabled
             attr_reader :maximum_file_size
             attr_reader :allowed_file_extensions
+            attr_reader :compression
             attr_reader :encryption
             attr_reader :antivirus
 
             def initialize(
                 id:,
-                read:,
-                write:,
-                permission:,
-                date_created:,
-                date_updated:,
+                created_at:,
+                updated_at:,
+                permissions:,
+                file_security:,
                 name:,
                 enabled:,
                 maximum_file_size:,
                 allowed_file_extensions:,
+                compression:,
                 encryption:,
                 antivirus:
             )
                 @id = id
-                @read = read
-                @write = write
-                @permission = permission
-                @date_created = date_created
-                @date_updated = date_updated
+                @created_at = created_at
+                @updated_at = updated_at
+                @permissions = permissions
+                @file_security = file_security
                 @name = name
                 @enabled = enabled
                 @maximum_file_size = maximum_file_size
                 @allowed_file_extensions = allowed_file_extensions
+                @compression = compression
                 @encryption = encryption
                 @antivirus = antivirus
             end
@@ -47,15 +47,15 @@ module Appwrite
             def self.from(map:)
                 Bucket.new(
                     id: map["$id"],
-                    read: map["$read"],
-                    write: map["$write"],
-                    permission: map["permission"],
-                    date_created: map["dateCreated"],
-                    date_updated: map["dateUpdated"],
+                    created_at: map["$createdAt"],
+                    updated_at: map["$updatedAt"],
+                    permissions: map["$permissions"],
+                    file_security: map["fileSecurity"],
                     name: map["name"],
                     enabled: map["enabled"],
                     maximum_file_size: map["maximumFileSize"],
                     allowed_file_extensions: map["allowedFileExtensions"],
+                    compression: map["compression"],
                     encryption: map["encryption"],
                     antivirus: map["antivirus"]
                 )
@@ -64,15 +64,15 @@ module Appwrite
             def to_map
                 {
                     "$id": @id,
-                    "$read": @read,
-                    "$write": @write,
-                    "permission": @permission,
-                    "dateCreated": @date_created,
-                    "dateUpdated": @date_updated,
+                    "$createdAt": @created_at,
+                    "$updatedAt": @updated_at,
+                    "$permissions": @permissions,
+                    "fileSecurity": @file_security,
                     "name": @name,
                     "enabled": @enabled,
                     "maximumFileSize": @maximum_file_size,
                     "allowedFileExtensions": @allowed_file_extensions,
+                    "compression": @compression,
                     "encryption": @encryption,
                     "antivirus": @antivirus
                 }

data/lib/appwrite/models/collection.rb

@@ -4,30 +4,36 @@ module Appwrite
     module Models
         class Collection
             attr_reader :id
-            attr_reader :read
-            attr_reader :write
+            attr_reader :created_at
+            attr_reader :updated_at
+            attr_reader :permissions
+            attr_reader :database_id
             attr_reader :name
             attr_reader :enabled
-            attr_reader :permission
+            attr_reader :document_security
             attr_reader :attributes
             attr_reader :indexes
 
             def initialize(
                 id:,
-                read:,
-                write:,
+                created_at:,
+                updated_at:,
+                permissions:,
+                database_id:,
                 name:,
                 enabled:,
-                permission:,
+                document_security:,
                 attributes:,
                 indexes:
             )
                 @id = id
-                @read = read
-                @write = write
+                @created_at = created_at
+                @updated_at = updated_at
+                @permissions = permissions
+                @database_id = database_id
                 @name = name
                 @enabled = enabled
-                @permission = permission
+                @document_security = document_security
                 @attributes = attributes
                 @indexes = indexes
             end
@@ -35,11 +41,13 @@ module Appwrite
             def self.from(map:)
                 Collection.new(
                     id: map["$id"],
-                    read: map["$read"],
-                    write: map["$write"],
+                    created_at: map["$createdAt"],
+                    updated_at: map["$updatedAt"],
+                    permissions: map["$permissions"],
+                    database_id: map["databaseId"],
                     name: map["name"],
                     enabled: map["enabled"],
-                    permission: map["permission"],
+                    document_security: map["documentSecurity"],
                     attributes: map["attributes"],
                     indexes: map["indexes"].map { |it| Index.from(map: it) }
                 )
@@ -48,11 +56,13 @@ module Appwrite
             def to_map
                 {
                     "$id": @id,
-                    "$read": @read,
-                    "$write": @write,
+                    "$createdAt": @created_at,
+                    "$updatedAt": @updated_at,
+                    "$permissions": @permissions,
+                    "databaseId": @database_id,
                     "name": @name,
                     "enabled": @enabled,
-                    "permission": @permission,
+                    "documentSecurity": @document_security,
                     "attributes": @attributes,
                     "indexes": @indexes.map { |it| it.to_map }
                 }