appwrite 24.1.0 → 24.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 117e69f27971b35ba99f0ccc63cfb9a3494955eef4e214048b38aa4ba57e1b80
-  data.tar.gz: d0e41de1a5f8550c33b3db61262a9e4f7b4facfafdfccc63f1e2a9d9947b045e
+  metadata.gz: 1815561145e36dee35678ad27a1bbdf13c53ed1fad59dd8c07805321f6073627
+  data.tar.gz: a4c4d5cf12077a7eedfb240b13c632040f3f8d220421704156b9cc07353e687f
 SHA512:
-  metadata.gz: 5ef18be9f1d2867aac51d1bd83955e5da5e9cf6f92d6d42759d1e7f45c1e95f4e66606e70e1e965e7092f3274923dd04f9cf041a51eaf9a6b7b0df085bfa31d7
-  data.tar.gz: 7afc04eac74397f0381624d0a3ddce3da33ff80468414856b6ec9e35028437ccee66bfc71f88af12c7f8242def21f63e783053112029271b4e90248a014b74b1
+  metadata.gz: '018c916f75afc5a11b45837d4498b371241156e5a765903815a6bfbefaf848b15b457b0988e384a3331b51c8cc291c52c9a0015bec63960ed73aee57f1886d8f'
+  data.tar.gz: 2274734af1f1c1434d2aa945d84d6ca704d7c155e633b2c71e58f086c69809b1c46af12a703769d46a3d087291eb22854dd57718ccc8c7e09eb7fb8017f0a628

data/lib/appwrite/client.rb

@@ -15,7 +15,7 @@ module Appwrite
                 'x-sdk-name'=> 'Ruby',
                 'x-sdk-platform'=> 'server',
                 'x-sdk-language'=> 'ruby',
-                'x-sdk-version'=> '24.1.0',
+                'x-sdk-version'=> '24.2.0',
                 'X-Appwrite-Response-Format' => '1.9.5'
             }
             @endpoint = 'https://cloud.appwrite.io/v1'
@@ -262,56 +262,133 @@ module Appwrite
 
             offset = 0
             id_param_name = id_param_name.to_sym if id_param_name
+            upload_id = nil
+            chunks_uploaded = 0
             if id_param_name&.empty? == false
+                upload_id = params[id_param_name]
                 # Make a request to check if a file already exists
-                current = call(
-                    method: "GET",
-                    path: "#{path}/#{params[id_param_name]}",
-                    headers: headers,
-                    params: {}
-                )
-                chunks_uploaded = current['chunksUploaded'].to_i
-                offset = chunks_uploaded * @chunk_size
+                begin
+                    current = call(
+                        method: "GET",
+                        path: "#{path}/#{params[id_param_name]}",
+                        headers: headers,
+                        params: {}
+                    )
+                    chunks_uploaded = current['chunksUploaded'].to_i
+                    offset = chunks_uploaded * @chunk_size
+                rescue Appwrite::Exception => error
+                    raise error unless error.code.to_i == 404
+                end
             end
 
+            total_chunks = (size.to_f / @chunk_size).ceil
+            chunks = []
             while offset < size
+                chunks << {
+                    index: chunks_uploaded.to_i,
+                    start: offset,
+                    ending: [offset + @chunk_size, size].min
+                }
+                offset += @chunk_size
+                chunks_uploaded = chunks_uploaded.to_i + 1
+            end
+
+            result = current if defined?(current)
+            return result unless chunks.any?
+
+            upload_chunk = lambda do |chunk, current_upload_id|
                 case input_file.source_type
                 when 'path'
-                    string = IO.read(input_file.path, @chunk_size, offset)
+                    string = IO.read(input_file.path, chunk[:ending] - chunk[:start], chunk[:start])
                 when 'string'
-                    string = input_file.data.byteslice(offset, [@chunk_size, size - offset].min)
+                    string = input_file.data.byteslice(chunk[:start], chunk[:ending] - chunk[:start])
                 end
 
-                params[param_name.to_sym] = InputFile::from_string(
+                chunk_params = params.merge(param_name.to_sym => InputFile::from_string(
                     string,
                     filename: input_file.filename,
                     mime_type: input_file.mime_type
-                )
+                ))
 
-                headers['content-range'] = "bytes #{offset}-#{[offset + @chunk_size - 1, size - 1].min}/#{size}"
+                chunk_headers = headers.merge('content-range' => "bytes #{chunk[:start]}-#{chunk[:ending] - 1}/#{size}")
+                chunk_headers['x-appwrite-id'] = current_upload_id if current_upload_id
 
-                result = call(
+                call(
                     method: 'POST',
                     path: path,
-                    headers: headers,
-                    params: params,
+                    headers: chunk_headers,
+                    params: chunk_params,
                 )
+            end
 
-                offset += @chunk_size
+            result = upload_chunk.call(chunks.first, upload_id)
+            upload_id = result['$id'] if result['$id']
+            completed_count = chunks.first[:index] + 1
+            uploaded_size = chunks.first[:ending]
 
-                if defined? result['$id']
-                    headers['x-appwrite-id'] = result['$id']
-                end
+            upload_complete = lambda do |chunk_result|
+                chunks_uploaded = chunk_result['chunksUploaded']
+                return false if chunks_uploaded.nil?
 
-                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['chunksTotal'],
-                    chunks_uploaded: result['chunksUploaded']
-                }) unless on_progress.nil?
+                chunks_total = chunk_result['chunksTotal'] || total_chunks
+                chunks_uploaded.to_i >= chunks_total.to_i
             end
 
+            on_progress.call({
+                id: result['$id'],
+                progress: uploaded_size.to_f/size.to_f * 100.0,
+                size_uploaded: uploaded_size,
+                chunks_total: result['chunksTotal'] || total_chunks,
+                chunks_uploaded: result['chunksUploaded'] || completed_count
+            }) unless on_progress.nil?
+
+            mutex = Mutex.new
+            queue = Queue.new
+            chunks.drop(1).each { |chunk| queue << chunk }
+            first_error = nil
+            last_result = result
+            completed_result = nil
+
+            workers = [8, queue.size].min.times.map do
+                Thread.new do
+                    loop do
+                        break if mutex.synchronize { !first_error.nil? }
+
+                        chunk = begin
+                            queue.pop(true)
+                        rescue ThreadError
+                            nil
+                        end
+                        break unless chunk
+
+                        begin
+                            chunk_result = upload_chunk.call(chunk, upload_id)
+                        rescue => error
+                            mutex.synchronize { first_error ||= error }
+                            break
+                        end
+                        mutex.synchronize do
+                            completed_count += 1
+                            uploaded_size += chunk[:ending] - chunk[:start]
+                            last_result = chunk_result
+                            completed_result = chunk_result if upload_complete.call(chunk_result)
+                            on_progress.call({
+                                id: upload_id,
+                                progress: uploaded_size.to_f/size.to_f * 100.0,
+                                size_uploaded: uploaded_size,
+                                chunks_total: chunk_result['chunksTotal'] || total_chunks,
+                                chunks_uploaded: chunk_result['chunksUploaded'] || completed_count
+                            }) unless on_progress.nil?
+                        end
+                    end
+                end
+            end
+
+            workers.each(&:join)
+            raise first_error if first_error
+
+            result = completed_result || last_result
+
             return result unless response_type.respond_to?("from")
 
             response_type.from(map: result)
@@ -329,8 +406,8 @@ module Appwrite
         )
             raise ArgumentError, 'Too Many HTTP Redirects' if limit == 0
 
-            @http = Net::HTTP.new(uri.host, uri.port) unless defined? @http
-            @http.use_ssl = !@self_signed
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = !@self_signed
             payload = ''
 
             headers = @headers.merge(headers)
@@ -351,7 +428,7 @@ module Appwrite
             end
 
             begin
-                response = @http.send_request(method, uri.request_uri, payload, headers)
+                response = http.send_request(method, uri.request_uri, payload, headers)
             rescue => error
                 raise Appwrite::Exception.new(error.message)
             end
@@ -382,7 +459,7 @@ module Appwrite
                 end
 
                 if response.code.to_i >= 400
-                    raise Appwrite::Exception.new(result['message'], result['status'], result['type'], response.body)
+                    raise Appwrite::Exception.new(result['message'], response.code, result['type'], response.body)
                 end
 
                 unless response_type.respond_to?("from")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appwrite
 version: !ruby/object:Gem::Version
-  version: 24.1.0
+  version: 24.2.0
 platform: ruby
 authors:
 - Appwrite Team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-20 00:00:00.000000000 Z
+date: 2026-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types