appwrite 2.4.1 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c1eb3f808d7681c19fb3ce67089478bd8407225953e985602d375e2826cebd5
-  data.tar.gz: be200991cd57aa18f7de0ea66ba32cddb0362475098799a177fb6b4e3614e063
+  metadata.gz: 9ccc9454e05eee3806e9bcb29e95ef8202b0fc617215e837e52a2cff52199bfd
+  data.tar.gz: 739353c7c628f0711f3c466c3d35f6db829bec9362415a735cf9ac3b72273a41
 SHA512:
-  metadata.gz: fc95e5305739fbcb2ca092a48d7b03f821d75fa686c853d1dd1110aef3e806e331e7df1cc91280ed7bfb8950878de61471100fb68c0fde0768a2faad13de040e
-  data.tar.gz: 5952f3051e0a25aa4913b9b64d8de94f3490d984e54139a6b76e5a139ed795358de993836ec63e3eb6660cb47881bad3e7608c18dee49d1054b57450746d1f89
+  metadata.gz: 483f458ce6e1b4abdeaeb96e60fabeb4f778fe775e39a1999abf19725f461a2db190b8b2b31f15d32d838436ac8b0e58bf6f1ce4f183e4a019d4fab75f0e8773
+  data.tar.gz: 91b5993ca7e9186e65150daf278751a510155d2d15a0de54169d9b6efdee376b93a99f512f75a649b32e04a389fe9ca8224e144c6905ccca4b11639930995478

data/lib/appwrite/client.rb

@@ -1,3 +1,5 @@
+#frozen_string_literal: true
+
 require 'net/http'
 require 'uri'
 require 'json'
@@ -5,136 +7,287 @@ require 'cgi'
 
 module Appwrite
     class Client
-        
-        METHOD_GET = 'get'
-        METHOD_POST = 'post'
-        METHOD_PUT = 'put'
-        METHOD_PATCH = 'patch'
-        METHOD_DELETE = 'delete'
-        METHOD_HEAD = 'head'
-        METHOD_OPTIONS = 'options'
-        METHOD_CONNECT = 'connect'
-        METHOD_TRACE = 'trace'
-
-        def initialize()
+
+        def initialize
+            @chunk_size = 5*1024*1024
             @headers = {
-                'content-type' => '',
                 'user-agent' => RUBY_PLATFORM + ':ruby-' + RUBY_VERSION,
-                'x-sdk-version' => 'appwrite:ruby:2.4.1',                
-                'X-Appwrite-Response-Format' => '0.11.0'
+                'x-sdk-version' => 'appwrite:ruby:4.1.0',                
+                'X-Appwrite-Response-Format' => '0.13.0'
             }
-            @endpoint = 'https://appwrite.io/v1';
+            @endpoint = 'https://HOSTNAME/v1'
         end
 
+        # Set Project
+        #
+        # Your project ID
+        #
+        # @param [String] value The value to set for the Project header
+        #
+        # @return [self]
         def set_project(value)
             add_header('x-appwrite-project', value)
 
-            return self
+            self
         end
 
+        # Set Key
+        #
+        # Your secret API key
+        #
+        # @param [String] value The value to set for the Key header
+        #
+        # @return [self]
         def set_key(value)
             add_header('x-appwrite-key', value)
 
-            return self
+            self
         end
 
+        # Set JWT
+        #
+        # Your secret JSON Web Token
+        #
+        # @param [String] value The value to set for the JWT header
+        #
+        # @return [self]
         def set_jwt(value)
             add_header('x-appwrite-jwt', value)
 
-            return self
+            self
         end
 
+        # Set Locale
+        #
+        # @param [String] value The value to set for the Locale header
+        #
+        # @return [self]
         def set_locale(value)
             add_header('x-appwrite-locale', value)
 
-            return self
+            self
         end
 
+        # Set endpoint.
+        #
+        # @param [String] endpoint The endpoint to set
+        #
+        # @return [self]
         def set_endpoint(endpoint)
             @endpoint = endpoint
             
-            return self
+            self
         end
-        
+
+        # Set self signed.
+        #
+        # @param [String] self_signed Whether to allow self signed certificates.
+        #
+        # @return [self]
+        def set_self_signed(self_signed = true)
+            @self_signed = self_signed
+
+            self
+        end
+
+
+        # Add Header
+        #
+        # @param [String] key The key for the header to add
+        # @param [String] value The value for the header to add
+        #
+        # @return [self]
         def add_header(key, value)
             @headers[key.downcase] = value
 
-            return self
+            self
         end
-        
-        def call(method, path = '', headers = {}, params = {})
-            uri = URI.parse(@endpoint + path + ((method == METHOD_GET && params.length) ? '?' + encode(params) : ''))
-            return fetch(method, uri, headers, params)
+
+        # Send the HTTP request.
+        #
+        # @param [String] method The HTTP method for the request
+        # @param [String] path The path for the request
+        # @param [Hash] headers The headers to send with the request
+        # @param [Hash] params The parameters to send with the request
+        # @param [Class] response_type The type of response to return
+        #
+        # @return [self]
+        def call(
+            method:,
+            path: '',
+            headers: {},
+            params: {},
+            response_type: nil
+        )
+            uri = URI.parse(@endpoint + path + ((method == "GET" && params.length) ? '?' + encode(params) : ''))
+
+            fetch(method, uri, headers, params, response_type)
         end
 
-        protected
+        def chunked_upload(
+            path:,
+            headers:,
+            params:,
+            param_name: '',
+            id_param_name: nil,
+            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
+
+            offset = 0
+            id_param_name = id_param_name.to_sym if id_param_name
+            if id_param_name&.empty? == false && params[id_param_name] != "unique()"
+                # 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 = [size, (chunks_uploaded * @chunk_size)].min
+            end
+
+            while offset < size
+                slice = IO.read(file_path, @chunk_size, offset)
+
+                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['chunksTotal'],
+                    chunks_uploaded: result['chunksUploaded']
+                }) unless on_progress.nil?
+            end
+
+            return result unless response_type.respond_to?("from")
+
+            response_type.from(map: result)
+        end
 
         private
 
-        def fetch(method, uri, headers, params, limit = 5)
+        def fetch(
+            method,
+            uri,
+            headers,
+            params,
+            response_type = nil,
+            limit = 5
+        )
             raise ArgumentError, 'Too Many HTTP Redirects' if limit == 0
 
-            http = Net::HTTP.new(uri.host, uri.port)
-            http.use_ssl = (uri.scheme == 'https')
+            @http = Net::HTTP.new(uri.host, uri.port) unless defined? @http
+            @http.use_ssl = !@self_signed
             payload = ''
             
             headers = @headers.merge(headers)
-            @BOUNDARY = "----A30#3ad1"
-            if (method != METHOD_GET)
-                case headers['content-type'][0, headers['content-type'].index(';') || headers['content-type'].length]
+
+            @boundary = "----A30#3ad1"
+            if method != "GET"
+                case headers[:'content-type']
                     when 'application/json'
                         payload = params.to_json
                     when 'multipart/form-data'
-                        payload = "--#{@BOUNDARY}\r\n" + encodeFormData(params)
-                        headers['content-type'] = "multipart/form-data; boundary=#{@BOUNDARY}"
+                        payload = "--#{@boundary}\r\n" + encode_form_data(params)
+                        headers[:'content-type'] = "multipart/form-data; boundary=#{@boundary}"
                     else
                         payload = encode(params)
                 end
             end
 
             begin
-                response = http.send_request(method.upcase, uri.request_uri, payload, headers)
+                response = @http.send_request(method, uri.request_uri, payload, headers)
             rescue => error
                 raise Appwrite::Exception.new(error.message)
             end
             
             # Handle Redirects
-            if (response.class == Net::HTTPRedirection || response.class == Net::HTTPMovedPermanently)
+            if response.class == Net::HTTPRedirection || response.class == Net::HTTPMovedPermanently
                 location = response['location']
                 uri = URI.parse(uri.scheme + "://" + uri.host + "" + location)
                 
-                return fetch(method, uri, headers, {}, limit - 1)
+                return fetch(method, uri, headers, {}, response_type, limit - 1)
             end
-            
-            begin
-                res = JSON.parse(response.body);
-            rescue JSON::ParserError => e
-                raise Appwrite::Exception.new(response.body, response.code, nil)
+
+            if response.content_type == 'application/json'
+                begin
+                    result = JSON.parse(response.body)
+                rescue JSON::ParserError => e
+                    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['type'], result)
+                end
+
+                unless response_type.respond_to?("from")
+                    return result
+                end
+
+                return response_type.from(map: result)
             end
 
-            if(response.code.to_i >= 400)
-                raise Appwrite::Exception.new(res['message'], res['status'], res)
+            if response.code.to_i >= 400
+                raise Appwrite::Exception.new(response.body, response.code, response)
             end
 
-            return res;
+            if response.respond_to?("body_permitted?")
+                return response.body if response.body_permitted?
+            end
+
+            return response
         end
         
-        def encodeFormData(value, key=nil)
+        def encode_form_data(value, key=nil)
             case value
-            when Hash  then value.map { |k,v| encodeFormData(v,k) }.join
-            when Array then value.map { |v| encodeFormData(v, "#{key}[]") }.join
-            when nil   then ''
+            when Hash
+                value.map { |k,v| encode_form_data(v,k) }.join
+            when Array
+                value.map { |v| encode_form_data(v, "#{key}[]") }.join
+            when nil
+                ''
             else
                 post_body = []
-                if(value.instance_of? File)
+                if value.instance_of? File
                     post_body << "Content-Disposition: form-data; name=\"#{key}\"; filename=\"#{value.name}\"\r\n"
-                    post_body << "Content-Type: #{value.mimeType}\r\n\r\n"
+                    post_body << "Content-Type: #{value.mime_type}\r\n\r\n"
                     post_body << value.content
-                    post_body << "\r\n--#{@BOUNDARY}--\r\n"
+                    post_body << "\r\n--#{@boundary}--\r\n"
                 else          
                     post_body << "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n"
                     post_body << "#{value.to_s}" 
-                    post_body << "\r\n--#{@BOUNDARY}\r\n"
+                    post_body << "\r\n--#{@boundary}\r\n"
                 end
                 post_body.join
             end
@@ -154,4 +307,4 @@ module Appwrite
             root_key.nil? ? key : "#{root_key}[#{key.to_s}]"
         end
     end 
-end
+end

data/lib/appwrite/exception.rb

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

data/lib/appwrite/file.rb

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

data/lib/appwrite/models/attribute_boolean.rb

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

data/lib/appwrite/models/attribute_email.rb

@@ -0,0 +1,57 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class AttributeEmail
+            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:)
+                AttributeEmail.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/attribute_enum.rb

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

data/lib/appwrite/models/attribute_float.rb

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