appwrite 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: faf26d54d0dd35ecb6279029fc13a153e824c91a0f6daa78dd0b3aa9b14e7337
-  data.tar.gz: 35bfcac6e7bcc0aeadc0a91a5ae07a9c18ab9f2d01e17f4e2132ff243f0f2690
+  metadata.gz: c885588668d4133732a6a6acf50beaa77734e71057417396d474e93b492029c5
+  data.tar.gz: 7711957f95eb038ad03e6c503a55dc61b3e0c7313e15308451a254cb35093b29
 SHA512:
-  metadata.gz: 072d20868a6b076d8dfa50f2c18d9f1c263523b871307cbaebd98df406f388bf6b7b6aff4b499a9f03168df2ead42cb45d20f4354559e38149e407d34f6a8d73
-  data.tar.gz: 52e32436fd5f535fabbc46bf0bde38df598a8ef7a0b2cc092ee9867943877854c00cfd8aa845d86090789b9a84eb0eeaeb0456460a4a8176c6a370f4f6747c03
+  metadata.gz: e7eb2a20711fd0e4f0650e39c89ae553d36f9f1e3dd2cdd5408b37555c6b75dbd45078018f5a68de3f5b568d91430871114e2afc287c5dbf058abe20ef33ea4d
+  data.tar.gz: 79804f75cbf28704a84d4c83401cc9873bc46bab9aa5b31198db05929f441fb6c8baee04adb3c04b0f385cbb0a5347df542ec37d6d1f80032c700a899c7a6a4e

data/lib/appwrite/client.rb

@@ -9,10 +9,11 @@ module Appwrite
     class Client
 
         def initialize
+            @chunk_size = 5*1024*1024
             @headers = {
                 'user-agent' => RUBY_PLATFORM + ':ruby-' + RUBY_VERSION,
-                'x-sdk-version' => 'appwrite:ruby:3.0.0',                
-                'X-Appwrite-Response-Format' => '0.12.0'
+                'x-sdk-version' => 'appwrite:ruby:4.0.0',                
+                'X-Appwrite-Response-Format' => '0.13.0'
             }
             @endpoint = 'https://HOSTNAME/v1'
         end
@@ -123,6 +124,65 @@ module Appwrite
             fetch(method, uri, headers, params, response_type)
         end
 
+        def chunked_upload(
+            path:,
+            headers:,
+            params:,
+            param_name: '',
+            on_progress: nil,
+            response_type: nil
+        )
+            file_path = params[param_name.to_sym]
+            size = ::File.size(file_path)
+
+            if size < @chunk_size
+                slice = ::File.read(file_path)
+                params[param_name] = File.new(file_path, slice)
+                return call(
+                    method: 'POST',
+                    path: path,
+                    headers: headers,
+                    params: params,
+                    response_type: response_type,
+                )
+            end
+
+            input = ::File.open(file_path)
+            offset = 0
+
+            while offset < size
+                slice = input.read(@chunk_size)
+
+                params[param_name] = File.new(file_path, slice)
+                headers['content-range'] = "bytes #{offset}-#{[offset + @chunk_size - 1, size].min}/#{size}"
+
+                result = call(
+                    method: 'POST',
+                    path: path,
+                    headers: headers,
+                    params: params,
+                )
+
+                offset += @chunk_size
+
+                if defined? result['$id']
+                    headers['x-Appwrite-id'] = result['$id']
+                end
+
+                on_progress.call({
+                    id: result['$id'],
+                    progress: ([offset, size].min).to_f/size.to_f * 100.0,
+                    size_uploaded: [offset, size].min,
+                    chunks_total: result['chunks_total'],
+                    chunks_uploaded: result['chunks_uploaded']
+                }) unless on_progress.nil?
+            end
+
+            return result unless response_type.respond_to?("from")
+
+            response_type.from(map: result)
+        end
+
         private
 
         def fetch(
@@ -172,11 +232,11 @@ module Appwrite
                 begin
                     result = JSON.parse(response.body)
                 rescue JSON::ParserError => e
-                    raise Appwrite::Exception.new(response.body, response.code, response)
+                    raise Appwrite::Exception.new(response.body, response.code, nil, response)
                 end
 
                 if response.code.to_i >= 400
-                    raise Appwrite::Exception.new(result['message'], result['status'], result)
+                    raise Appwrite::Exception.new(result['message'], result['status'], result['type'], result)
                 end
 
                 unless response_type.respond_to?("from")
@@ -190,7 +250,11 @@ module Appwrite
                 raise Appwrite::Exception.new(response.body, response.code, response)
             end
 
-            return response.body if response.body_permitted?
+            if response.respond_to?("body_permitted?")
+                return response.body if response.body_permitted?
+            end
+
+            return response
         end
         
         def encode_form_data(value, key=nil)

data/lib/appwrite/exception.rb

@@ -2,10 +2,12 @@ module Appwrite
     class Exception < StandardError
         attr_reader :code
         attr_reader :response
+        attr_reader :type
         
-        def initialize(message, code = 0, response = nil)
+        def initialize(message, code = 0, type = nil, response = nil)
             super(message)
             @code = code
+            @type = type
             @response = response
         end
     end

data/lib/appwrite/file.rb

@@ -2,13 +2,15 @@ require 'mime/types'
 
 module Appwrite
     class File
+        attr_reader :path
         attr_reader :name
         attr_reader :content
         attr_reader :mime_type
 
-        def initialize(path)
+        def initialize(path, content)
+            @path = path
+            @content = content
             @name = ::File.basename(path)
-            @content = ::File.read(path)
             @mime_type = MIME::Types.type_for(path)
         end
     end

data/lib/appwrite/models/attribute_list.rb

@@ -3,27 +3,27 @@
 module Appwrite
     module Models
         class AttributeList
-            attr_reader :sum
+            attr_reader :total
             attr_reader :attributes
 
             def initialize(
-                sum:,
+                total:,
                 attributes:
             )
-                @sum = sum
+                @total = total
                 @attributes = attributes
             end
 
             def self.from(map:)
                 AttributeList.new(
-                    sum: map["sum"],
+                    total: map["total"],
                     attributes: map["attributes"]
                 )
             end
 
             def to_map
                 {
-                    "sum": @sum,
+                    "total": @total,
                     "attributes": @attributes
                 }
             end

data/lib/appwrite/models/bucket.rb

@@ -0,0 +1,82 @@
+#frozen_string_literal: true
+
+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 :name
+            attr_reader :enabled
+            attr_reader :maximum_file_size
+            attr_reader :allowed_file_extensions
+            attr_reader :encryption
+            attr_reader :antivirus
+
+            def initialize(
+                id:,
+                read:,
+                write:,
+                permission:,
+                date_created:,
+                date_updated:,
+                name:,
+                enabled:,
+                maximum_file_size:,
+                allowed_file_extensions:,
+                encryption:,
+                antivirus:
+            )
+                @id = id
+                @read = read
+                @write = write
+                @permission = permission
+                @date_created = date_created
+                @date_updated = date_updated
+                @name = name
+                @enabled = enabled
+                @maximum_file_size = maximum_file_size
+                @allowed_file_extensions = allowed_file_extensions
+                @encryption = encryption
+                @antivirus = antivirus
+            end
+
+            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"],
+                    name: map["name"],
+                    enabled: map["enabled"],
+                    maximum_file_size: map["maximumFileSize"],
+                    allowed_file_extensions: map["allowedFileExtensions"],
+                    encryption: map["encryption"],
+                    antivirus: map["antivirus"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$read": @read,
+                    "$write": @write,
+                    "permission": @permission,
+                    "dateCreated": @date_created,
+                    "dateUpdated": @date_updated,
+                    "name": @name,
+                    "enabled": @enabled,
+                    "maximumFileSize": @maximum_file_size,
+                    "allowedFileExtensions": @allowed_file_extensions,
+                    "encryption": @encryption,
+                    "antivirus": @antivirus
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/bucket_list.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class BucketList
+            attr_reader :total
+            attr_reader :buckets
+
+            def initialize(
+                total:,
+                buckets:
+            )
+                @total = total
+                @buckets = buckets
+            end
+
+            def self.from(map:)
+                BucketList.new(
+                    total: map["total"],
+                    buckets: map["buckets"].map { |it| Bucket.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "total": @total,
+                    "buckets": @buckets.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/collection_list.rb

@@ -3,27 +3,27 @@
 module Appwrite
     module Models
         class CollectionList
-            attr_reader :sum
+            attr_reader :total
             attr_reader :collections
 
             def initialize(
-                sum:,
+                total:,
                 collections:
             )
-                @sum = sum
+                @total = total
                 @collections = collections
             end
 
             def self.from(map:)
                 CollectionList.new(
-                    sum: map["sum"],
+                    total: map["total"],
                     collections: map["collections"].map { |it| Collection.from(map: it) }
                 )
             end
 
             def to_map
                 {
-                    "sum": @sum,
+                    "total": @total,
                     "collections": @collections.map { |it| it.to_map }
                 }
             end

data/lib/appwrite/models/continent_list.rb

@@ -3,27 +3,27 @@
 module Appwrite
     module Models
         class ContinentList
-            attr_reader :sum
+            attr_reader :total
             attr_reader :continents
 
             def initialize(
-                sum:,
+                total:,
                 continents:
             )
-                @sum = sum
+                @total = total
                 @continents = continents
             end
 
             def self.from(map:)
                 ContinentList.new(
-                    sum: map["sum"],
+                    total: map["total"],
                     continents: map["continents"].map { |it| Continent.from(map: it) }
                 )
             end
 
             def to_map
                 {
-                    "sum": @sum,
+                    "total": @total,
                     "continents": @continents.map { |it| it.to_map }
                 }
             end

data/lib/appwrite/models/country_list.rb

@@ -3,27 +3,27 @@
 module Appwrite
     module Models
         class CountryList
-            attr_reader :sum
+            attr_reader :total
             attr_reader :countries
 
             def initialize(
-                sum:,
+                total:,
                 countries:
             )
-                @sum = sum
+                @total = total
                 @countries = countries
             end
 
             def self.from(map:)
                 CountryList.new(
-                    sum: map["sum"],
+                    total: map["total"],
                     countries: map["countries"].map { |it| Country.from(map: it) }
                 )
             end
 
             def to_map
                 {
-                    "sum": @sum,
+                    "total": @total,
                     "countries": @countries.map { |it| it.to_map }
                 }
             end

data/lib/appwrite/models/currency_list.rb

@@ -3,27 +3,27 @@
 module Appwrite
     module Models
         class CurrencyList
-            attr_reader :sum
+            attr_reader :total
             attr_reader :currencies
 
             def initialize(
-                sum:,
+                total:,
                 currencies:
             )
-                @sum = sum
+                @total = total
                 @currencies = currencies
             end
 
             def self.from(map:)
                 CurrencyList.new(
-                    sum: map["sum"],
+                    total: map["total"],
                     currencies: map["currencies"].map { |it| Currency.from(map: it) }
                 )
             end
 
             def to_map
                 {
-                    "sum": @sum,
+                    "total": @total,
                     "currencies": @currencies.map { |it| it.to_map }
                 }
             end

data/lib/appwrite/models/deployment.rb

@@ -0,0 +1,77 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Deployment
+            attr_reader :id
+            attr_reader :resource_id
+            attr_reader :resource_type
+            attr_reader :date_created
+            attr_reader :entrypoint
+            attr_reader :size
+            attr_reader :build_id
+            attr_reader :activate
+            attr_reader :status
+            attr_reader :build_stdout
+            attr_reader :build_stderr
+
+            def initialize(
+                id:,
+                resource_id:,
+                resource_type:,
+                date_created:,
+                entrypoint:,
+                size:,
+                build_id:,
+                activate:,
+                status:,
+                build_stdout:,
+                build_stderr:
+            )
+                @id = id
+                @resource_id = resource_id
+                @resource_type = resource_type
+                @date_created = date_created
+                @entrypoint = entrypoint
+                @size = size
+                @build_id = build_id
+                @activate = activate
+                @status = status
+                @build_stdout = build_stdout
+                @build_stderr = build_stderr
+            end
+
+            def self.from(map:)
+                Deployment.new(
+                    id: map["$id"],
+                    resource_id: map["resourceId"],
+                    resource_type: map["resourceType"],
+                    date_created: map["dateCreated"],
+                    entrypoint: map["entrypoint"],
+                    size: map["size"],
+                    build_id: map["buildId"],
+                    activate: map["activate"],
+                    status: map["status"],
+                    build_stdout: map["buildStdout"],
+                    build_stderr: map["buildStderr"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "resourceId": @resource_id,
+                    "resourceType": @resource_type,
+                    "dateCreated": @date_created,
+                    "entrypoint": @entrypoint,
+                    "size": @size,
+                    "buildId": @build_id,
+                    "activate": @activate,
+                    "status": @status,
+                    "buildStdout": @build_stdout,
+                    "buildStderr": @build_stderr
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/deployment_list.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DeploymentList
+            attr_reader :total
+            attr_reader :deployments
+
+            def initialize(
+                total:,
+                deployments:
+            )
+                @total = total
+                @deployments = deployments
+            end
+
+            def self.from(map:)
+                DeploymentList.new(
+                    total: map["total"],
+                    deployments: map["deployments"].map { |it| Deployment.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "total": @total,
+                    "deployments": @deployments.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/document_list.rb

@@ -3,27 +3,27 @@
 module Appwrite
     module Models
         class DocumentList
-            attr_reader :sum
+            attr_reader :total
             attr_reader :documents
 
             def initialize(
-                sum:,
+                total:,
                 documents:
             )
-                @sum = sum
+                @total = total
                 @documents = documents
             end
 
             def self.from(map:)
                 DocumentList.new(
-                    sum: map["sum"],
+                    total: map["total"],
                     documents: map["documents"].map { |it| Document.from(map: it) }
                 )
             end
 
             def to_map
                 {
-                    "sum": @sum,
+                    "total": @total,
                     "documents": @documents.map { |it| it.to_map }
                 }
             end

data/lib/appwrite/models/execution.rb

@@ -9,7 +9,7 @@ module Appwrite
             attr_reader :date_created
             attr_reader :trigger
             attr_reader :status
-            attr_reader :exit_code
+            attr_reader :status_code
             attr_reader :stdout
             attr_reader :stderr
             attr_reader :time
@@ -21,7 +21,7 @@ module Appwrite
                 date_created:,
                 trigger:,
                 status:,
-                exit_code:,
+                status_code:,
                 stdout:,
                 stderr:,
                 time:
@@ -32,7 +32,7 @@ module Appwrite
                 @date_created = date_created
                 @trigger = trigger
                 @status = status
-                @exit_code = exit_code
+                @status_code = status_code
                 @stdout = stdout
                 @stderr = stderr
                 @time = time
@@ -46,7 +46,7 @@ module Appwrite
                     date_created: map["dateCreated"],
                     trigger: map["trigger"],
                     status: map["status"],
-                    exit_code: map["exitCode"],
+                    status_code: map["statusCode"],
                     stdout: map["stdout"],
                     stderr: map["stderr"],
                     time: map["time"]
@@ -61,7 +61,7 @@ module Appwrite
                     "dateCreated": @date_created,
                     "trigger": @trigger,
                     "status": @status,
-                    "exitCode": @exit_code,
+                    "statusCode": @status_code,
                     "stdout": @stdout,
                     "stderr": @stderr,
                     "time": @time

data/lib/appwrite/models/execution_list.rb

@@ -3,27 +3,27 @@
 module Appwrite
     module Models
         class ExecutionList
-            attr_reader :sum
+            attr_reader :total
             attr_reader :executions
 
             def initialize(
-                sum:,
+                total:,
                 executions:
             )
-                @sum = sum
+                @total = total
                 @executions = executions
             end
 
             def self.from(map:)
                 ExecutionList.new(
-                    sum: map["sum"],
+                    total: map["total"],
                     executions: map["executions"].map { |it| Execution.from(map: it) }
                 )
             end
 
             def to_map
                 {
-                    "sum": @sum,
+                    "total": @total,
                     "executions": @executions.map { |it| it.to_map }
                 }
             end