nylas 5.0.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82a2a7e6af812dd58557c604deb553e18d586c373ee8c308b1eddc8492a44c28
-  data.tar.gz: 43b9a7943a854c10f2257d49220fc420ff4e3b022b76a527ba772041600d24dd
+  metadata.gz: d2f677958900566f6aeb941f450e9bbe3b4dfd54f57c4cf4b87bb403f968f731
+  data.tar.gz: 5f4eb58cf5835a43a4034229d506d7662923fa110c4fe5e352f9d867ac69b295
 SHA512:
-  metadata.gz: 6c005ca3d6e0f61bc25ebdab118cc0dda5dd366c24b8ad1519b78a5bb32bd0de976b1070fb6dc35dfbd81ffd4540c636956c38f1248e412e80441cf12fb788d0
-  data.tar.gz: 05e47ffa2fb00e66adf7483b7eb7a0bd870c85dbff006dee3cfa7b968589173634d77d74519bc04e657d214efdfd17b1bc8ef492da0880edef5552fb012ac466
+  metadata.gz: c727f58c5ecaeaca411d346b23d2176f8114f1cc441347326c8c26239f3ef78626007a443f89932fc955c68c295229d238a647cb7f42234f11d31fc0d02ec7e9
+  data.tar.gz: e1ce86d59fcdc7c7193688faf95833978e106fb5e0ea5166f009f9f06234e9a724e363b21133b6636c14398e4dcc177853347b13a5c821af765deaf5900a0cc4

data/lib/nylas/contact.rb

@@ -13,9 +13,9 @@ module Nylas
     self.updatable = true
     self.destroyable = true
 
-    attribute :id, :string, exclude_when: %i[creating updating]
+    attribute :id, :string, read_only: true
     attribute :object, :string, default: "contact"
-    attribute :account_id, :string, exclude_when: %i[creating updating]
+    attribute :account_id, :string, read_only: true
 
     attribute :given_name, :string
     attribute :middle_name, :string

data/lib/nylas/delta.rb

@@ -6,6 +6,7 @@ module Nylas
   # @see https://docs.nylas.com/reference#deltas
   class Delta
     include Model::Attributable
+
     attribute :id, :string
     attribute :type, :string
     attribute :object, :string
@@ -24,6 +25,8 @@ module Nylas
       @model ||= Types.registry[object.to_sym].cast(object_attributes_with_ids)
     end
 
+    private
+
     def object_attributes_with_ids
       (object_attributes || {}).merge(id: id, account_id: account_id)
     end
@@ -42,8 +45,10 @@ module Nylas
              else
                data
              end
+
+      data = data.merge(data[:attributes]) if data[:attributes]
       data[:object_attributes] = data.delete(:attributes)
-      super(data)
+      super(**data)
     end
   end
 end

data/lib/nylas/deltas.rb

@@ -14,6 +14,6 @@ module Nylas
     attribute :cursor_end, :string
 
     extend Forwardable
-    def_delegators :deltas, :count, :length, :each, :map, :first, :to_a, :empty?
+    def_delegators :deltas, :count, :length, :each, :map, :first, :last, :to_a, :empty?
   end
 end

data/lib/nylas/draft.rb

@@ -29,7 +29,8 @@ module Nylas
     attribute :unread, :boolean
 
     has_n_of_attribute :events, :event
-    has_n_of_attribute :files, :file
+    has_n_of_attribute :files, :file, read_only: true
+    has_n_of_attribute :file_ids, :string
     attribute :folder, :folder
     has_n_of_attribute :labels, :label
 
@@ -37,6 +38,20 @@ module Nylas
 
     transfer :api, to: %i[events files folder labels]
 
+    def update(**data)
+      self.files = data[:files] if data[:files]
+      extract_file_ids!
+      data[:file_ids] = file_ids
+
+      super
+    end
+
+    def create
+      extract_file_ids!
+
+      super
+    end
+
     def send!
       return execute(method: :post, path: "/send", payload: to_json) if tracking
 
@@ -53,7 +68,21 @@ module Nylas
     end
 
     def destroy
-      execute(method: :delete, path: resource_path, payload: attributes.serialize(keys: [:version]))
+      execute(method: :delete, path: resource_path, payload: attributes.serialize_for_api(keys: [:version]))
+    end
+
+    private
+
+    def save_call
+      extract_file_ids!
+
+      super
+    end
+
+    def extract_file_ids!
+      files = self.files || []
+
+      self.file_ids = files.map(&:id)
     end
   end
 end

data/lib/nylas/event.rb

@@ -9,9 +9,9 @@ module Nylas
     allows_operations(creatable: true, listable: true, filterable: true, showable: true, updatable: true,
                       destroyable: true)
 
-    attribute :id, :string, exclude_when: %i[saving]
-    attribute :object, :string, exclude_when: %i[saving]
-    attribute :account_id, :string, exclude_when: %i[saving]
+    attribute :id, :string, read_only: true
+    attribute :object, :string, read_only: true
+    attribute :account_id, :string, read_only: true
     attribute :calendar_id, :string
     attribute :master_event_id, :string
     attribute :message_id, :string
@@ -27,6 +27,7 @@ module Nylas
     attribute :status, :string
     attribute :title, :string
     attribute :when, :when
+    attribute :metadata, :hash
     attribute :original_start_time, :unix_timestamp
 
     attr_accessor :notify_participants

data/lib/nylas/http_client.rb

@@ -104,8 +104,8 @@ module Nylas
                         also_log: { result: true, values: %i[method url path headers query payload] }
 
     def build_request(method:, path: nil, headers: {}, query: {}, payload: nil, timeout: nil)
-      headers[:params] = query
       url ||= url_for_path(path)
+      url = add_query_params_to_url(url, query)
       resulting_headers = default_headers.merge(headers)
       { method: method, url: url, payload: payload, headers: resulting_headers, timeout: timeout }
     end
@@ -178,10 +178,39 @@ module Nylas
 
     def handle_anticipated_failure_mode(http_code:, response:)
       return if http_code == 200
-      return unless response.is_a?(Hash)
 
       exception = HTTP_CODE_TO_EXCEPTIONS.fetch(http_code, APIError)
-      raise exception.new(response[:type], response[:message], response.fetch(:server_error, nil))
+      parsed_response = parse_response(response)
+
+      raise exception.new(
+        parsed_response[:type],
+        parsed_response[:message],
+        parsed_response.fetch(:server_error, nil)
+      )
+    end
+
+    def add_query_params_to_url(url, query)
+      unless query.empty?
+        uri = URI.parse(url)
+        query = custom_params(query)
+        params = URI.decode_www_form(uri.query || "") + query.to_a
+        uri.query = URI.encode_www_form(params)
+        url = uri.to_s
+      end
+
+      url
+    end
+
+    def custom_params(query)
+      # Convert hash to "<key>:<value>" form for metadata_pair query
+      if query.key?(:metadata_pair)
+        pairs = query[:metadata_pair].map do |key, value|
+          "#{key}:#{value}"
+        end
+        query[:metadata_pair] = pairs
+      end
+
+      query
     end
   end
 end

data/lib/nylas/message.rb

@@ -37,7 +37,7 @@ module Nylas
     attribute :folder, :folder
     attribute :folder_id, :string
 
-    has_n_of_attribute :labels, :label, exclude_when: [:saving]
+    has_n_of_attribute :labels, :label, read_only: true
     has_n_of_attribute :label_ids, :string
 
     transfer :api, to: %i[events files folder labels]
@@ -75,7 +75,7 @@ module Nylas
 
       execute(
         method: :put,
-        payload: attributes.serialize(keys: allowed_keys_for_save),
+        payload: attributes.serialize_for_api,
         path: resource_path
       )
     end

data/lib/nylas/model.rb

@@ -48,7 +48,7 @@ module Nylas
 
       execute(
         method: :post,
-        payload: attributes.serialize,
+        payload: attributes.serialize_for_api,
         path: resources_path,
         query: query_params
       )
@@ -58,12 +58,37 @@ module Nylas
       raise ModelNotUpdatableError, model_class unless updatable?
 
       attributes.merge(**data)
-      execute(
-        method: :put,
-        payload: attributes.serialize(keys: data.keys),
-        path: resource_path,
-        query: query_params
-      )
+      payload = attributes.serialize_for_api(keys: data.keys)
+      update_call(payload)
+
+      true
+    rescue Registry::MissingKeyError => e
+      raise ModelMissingFieldError.new(e.key, self)
+    end
+
+    def save_all_attributes
+      result = if persisted?
+                 raise ModelNotUpdatableError, self unless updatable?
+
+                 execute(
+                   method: :put,
+                   payload: attributes.serialize_all_for_api,
+                   path: resource_path
+                 )
+               else
+                 create
+               end
+
+      attributes.merge(result)
+    end
+
+    def update_all_attributes(**data)
+      raise ModelNotUpdatableError, model_class unless updatable?
+
+      attributes.merge(**data)
+      payload = attributes.serialize_all_for_api(keys: data.keys)
+      update_call(payload)
+
       true
     rescue Registry::MissingKeyError => e
       raise ModelMissingFieldError.new(e.key, self)
@@ -95,20 +120,24 @@ module Nylas
 
     private
 
-    def allowed_keys_for_save
-      attributes.attribute_definitions.to_h.reject do |_k, v|
-        v.exclude_when.include?(:saving)
-      end.keys
-    end
-
     def save_call
       execute(
         method: :put,
-        payload: attributes.serialize(keys: allowed_keys_for_save),
+        payload: attributes.serialize_for_api,
         path: resource_path
       )
     end
 
+    def update_call(payload)
+      result = execute(
+        method: :put,
+        payload: payload,
+        path: resource_path,
+        query: query_params
+      )
+      attributes.merge(result) if result
+    end
+
     def query_params
       {}
     end

data/lib/nylas/model/attributable.rb

@@ -34,17 +34,22 @@ module Nylas
       # Methods to call when tweaking Attributable classes
       module ClassMethods
         # rubocop:disable Naming/PredicateName
-        def has_n_of_attribute(name, type_name, exclude_when: [], default: [])
-          attribute_definitions[name] = ListAttributeDefinition.new(type_name: type_name,
-                                                                    exclude_when: exclude_when,
-                                                                    default: default)
+        def has_n_of_attribute(name, type_name, read_only: false, default: [])
+          attribute_definitions[name] = ListAttributeDefinition.new(
+            type_name: type_name,
+            read_only: read_only,
+            default: default
+          )
           define_accessors(name)
         end
         # rubocop:enable Naming/PredicateName
 
-        def attribute(name, type_name, exclude_when: [], default: nil)
-          attribute_definitions[name] = AttributeDefinition.new(type_name: type_name,
-                                                                exclude_when: exclude_when, default: default)
+        def attribute(name, type_name, read_only: false, default: nil)
+          attribute_definitions[name] = AttributeDefinition.new(
+            type_name: type_name,
+            read_only: read_only,
+            default: default
+          )
           define_accessors(name)
         end
 

data/lib/nylas/model/attribute_definition.rb

@@ -6,11 +6,11 @@ module Nylas
     class AttributeDefinition
       extend Forwardable
       def_delegators :type, :cast, :serialize
-      attr_accessor :type_name, :exclude_when, :default
+      attr_accessor :type_name, :read_only, :default
 
-      def initialize(type_name:, exclude_when:, default:)
+      def initialize(type_name:, read_only:, default:)
         self.type_name = type_name
-        self.exclude_when = exclude_when
+        self.read_only = read_only
         self.default = default
       end
 

data/lib/nylas/model/attributes.rb

@@ -39,6 +39,22 @@ module Nylas
         JSON.dump(to_h(keys: keys))
       end
 
+      def serialize_for_api(keys: attribute_definitions.keys)
+        api_keys = keys.delete_if { |key| attribute_definitions[key].read_only == true }
+
+        serialize(keys: api_keys)
+      end
+
+      def serialize_all_for_api(keys: attribute_definitions.keys)
+        api_keys = keys.delete_if { |key| attribute_definitions[key].read_only == true }
+
+        JSON.dump(
+          api_keys.each_with_object({}) do |key, casted_data|
+            casted_data[key] = attribute_definitions[key].serialize(self[key])
+          end
+        )
+      end
+
       private
 
       def cast(key, value)

data/lib/nylas/model/list_attribute_definition.rb

@@ -4,11 +4,11 @@ module Nylas
   module Model
     # Allows models to have an attribute which is a lists of another type of thing
     class ListAttributeDefinition
-      attr_accessor :type_name, :exclude_when, :default
+      attr_accessor :type_name, :read_only, :default
 
-      def initialize(type_name:, exclude_when:, default:)
+      def initialize(type_name:, read_only:, default:)
         self.type_name = type_name
-        self.exclude_when = exclude_when
+        self.read_only = read_only
         self.default = default
       end
 

data/lib/nylas/rsvp.rb

@@ -13,8 +13,12 @@ module Nylas
     attr_accessor :notify_participants
 
     def save
-      api.execute(method: :post, path: "/send-rsvp", payload: attributes.serialize,
-                  query: { notify_participants: notify_participants })
+      api.execute(
+        method: :post,
+        path: "/send-rsvp",
+        payload: attributes.serialize_for_api,
+        query: { notify_participants: notify_participants }
+      )
     end
   end
 end

data/lib/nylas/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nylas
-  VERSION = "5.0.0"
+  VERSION = "5.1.0"
 end

data/lib/nylas/when.rb

@@ -8,7 +8,7 @@ module Nylas
 
     include Model::Attributable
 
-    attribute :object, :string
+    attribute :object, :string, read_only: true
 
     # when object == 'date'
     attribute :date, :date

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nylas
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Nylas, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-07 00:00:00.000000000 Z
+date: 2021-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -345,7 +345,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.17
 signing_key:
 specification_version: 4
 summary: Gem for interacting with the Nylas API