appwrite 2.2.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ff4eead29ef5fcae244fbcc93ee35d51d26c04d44f6cae00bde1a35d7cd4590
-  data.tar.gz: 0fee5b3c85b96692adcf9c29b024986bce8c5ff7fd935b4d9e67e1fea48685f8
+  metadata.gz: faf26d54d0dd35ecb6279029fc13a153e824c91a0f6daa78dd0b3aa9b14e7337
+  data.tar.gz: 35bfcac6e7bcc0aeadc0a91a5ae07a9c18ab9f2d01e17f4e2132ff243f0f2690
 SHA512:
-  metadata.gz: 7ee92d121c635eb76a2f872a8446d2516925b353fbb97fa3dba0c342730fe131cf537bfe49aece631442ab37704b624d8dd4e02a14d9fe9ca645038ee0501eae
-  data.tar.gz: 3e0f8d737f3340996e1b2414991a143863c5e76c61edbd688d165cd98909394aa5dbd4ab92791b925659325e41899fb9d25d9f5c8be4cca5efb299ae17863a64
+  metadata.gz: 072d20868a6b076d8dfa50f2c18d9f1c263523b871307cbaebd98df406f388bf6b7b6aff4b499a9f03168df2ead42cb45d20f4354559e38149e407d34f6a8d73
+  data.tar.gz: 52e32436fd5f535fabbc46bf0bde38df598a8ef7a0b2cc092ee9867943877854c00cfd8aa845d86090789b9a84eb0eeaeb0456460a4a8176c6a370f4f6747c03

data/lib/appwrite/client.rb

@@ -1,3 +1,5 @@
+#frozen_string_literal: true
+
 require 'net/http'
 require 'uri'
 require 'json'
@@ -5,136 +7,211 @@ 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
             @headers = {
-                'content-type' => '',
                 'user-agent' => RUBY_PLATFORM + ':ruby-' + RUBY_VERSION,
-                'x-sdk-version' => 'appwrite:ruby:2.2.0',                
-                'X-Appwrite-Response-Format' => '0.8.0'
+                'x-sdk-version' => 'appwrite:ruby:3.0.0',                
+                'X-Appwrite-Response-Format' => '0.12.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
-        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)
+            self
         end
 
-        protected
+        # 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
 
         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, response)
+                end
+
+                if response.code.to_i >= 400
+                    raise Appwrite::Exception.new(result['message'], result['status'], 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;
+            return response.body if response.body_permitted?
         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 +231,4 @@ module Appwrite
             root_key.nil? ? key : "#{root_key}[#{key.to_s}]"
         end
     end 
-end
+end

data/lib/appwrite/exception.rb

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

data/lib/appwrite/file.rb

@@ -2,22 +2,14 @@ require 'mime/types'
 
 module Appwrite
     class File
+        attr_reader :name
+        attr_reader :content
+        attr_reader :mime_type
+
         def initialize(path)
             @name = ::File.basename(path)
             @content = ::File.read(path)
-            @mimeType = MIME::Types.type_for(path)
-        end
-
-        def name
-            @name
-        end
-
-        def content
-            @content
-        end
-
-        def mimeType
-            @mimeType
+            @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

data/lib/appwrite/models/attribute_integer.rb

@@ -0,0 +1,62 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class AttributeInteger
+            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:)
+                AttributeInteger.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