microslop_one_drive 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8dad115ceda6d13e87dfa8ce0e5d9b1d9e451a5000da6fa4feea51a66cf0a5f
-  data.tar.gz: 32162a0c944a59cfcdf3a80497d599e899d995fde9286555f11b4d09223b8cfc
+  metadata.gz: 62f6bca1662f2c07a1b60c1c4913cb6bfd38bf91ba1aa5b1967c6fd6d934449e
+  data.tar.gz: 4c2c0331fb82cffaee9e577e199c9080d65e21b0bab21c4bb0e453b6bf3f96fb
 SHA512:
-  metadata.gz: fe6c984e15650dc7a03c4299674122518bb55dabe9aac1943d03d0792003a0580a231a121cb7a93dd2dadaafd587992f2a747599d0eb1faf03f79bc272661db1
-  data.tar.gz: 5e3d86ad896bd39c942d014e2b33cc58a0b80db859b36c856049396dee10d99b3abff74af702a5a9abe1d05376746bf0c85403be7853d80f10c05c0d88f07fca
+  metadata.gz: e94c8e9605382067d47f07795f6804b77e57a12e2e40a42a83f51451732acbe188377caa7e3c25dc1de4340a6ff32d5418282afeafd28946a6737224fda78cad
+  data.tar.gz: b244b1834e892720324401b7e6f688b4791bb7c406acd76fa8d2c326d8c7b53667aa714f62ec6fc09f7829a513782db27c74a85d773b1a0db915b7450cd5bb23

data/README.md

@@ -16,8 +16,7 @@ gem "microslop_one_drive"
 
 ## Usage
 
-Here's a quickstart showing listing drives, getting some files in a drive, and getting permissions for some files in
-a batched manner:
+Quickstart: current user, drives, drive items, shared-with-me, delta (changes), and permissions (single or batched).
 
 ### Creating a client
 
@@ -25,6 +24,17 @@ a batched manner:
 access_token = "..." # Get an access token via OAuth 2.0
 
 client = MicroslopOneDrive::Client.new(access_token)
+
+# Optional: pass a logger to log all API requests and responses (e.g. Rails.logger)
+client = MicroslopOneDrive::Client.new(access_token, logger: Rails.logger)
+```
+
+### Get current user
+
+```rb
+user = client.me
+user.display_name # => "Jane Doe"
+user.email_address # => "jane@example.com"
 ```
 
 ### Listing Drives
@@ -34,7 +44,7 @@ Note: Microsoft will return all Drives a user has access to. Some of these seem
 `drive_exists?()` method to check if it's a real drive you can interact with.
 
 ```rb
-drive_list = client.drives
+drive_list = client.all_drives
 drive_list.drives.size # => 2
 
 drive = drive_list.drives[1]
@@ -44,6 +54,29 @@ drive.id # => "0f0**********42"
 client.drive_exists?(drive.id) # => true (it's a real Drive)
 ```
 
+### Get a single drive
+
+```rb
+# Default (current user's) drive
+drive = client.drive
+
+# Or a specific drive by ID
+drive = client.drive(drive_id: "0f0**********42")
+drive.name # => "OneDrive"
+```
+
+### Get a single drive item
+
+```rb
+item = client.drive_item(item_id: "01ABC123...", drive_id: drive.id)
+item.name # => "My Document.docx"
+item.file? # => true
+item.folder? # => false
+
+# Check if an item exists without raising
+client.drive_item_exists?(item_id: "01ABC123...", drive_id: drive.id) # => true
+```
+
 ### Listing Drive Items (Folders and Files)
 
 ```rb
@@ -59,6 +92,34 @@ delta_token = page2.delta_token # Save this somewhere and use as "token" in the
 # only get new changes, and don't list the whole drive from the beginning again.
 ```
 
+### Shared with me
+
+Get drive items (files and folders) that others have shared with the current user.
+
+```rb
+shared_list = client.shared_with_me
+shared_list.shared_with_me_items.size # => 5
+
+item = shared_list.shared_with_me_items.first
+item.name # => "Spreadsheet One.xlsx"
+item.id # => "64E5DD3210FD6004!s1d8ad87a1d6e4d4e..."
+item.web_url # => "https://onedrive.live.com?cid=..."
+item.size # => 6183
+item.created_at # => 2026-02-17 14:27:26 UTC
+item.updated_at # => 2026-02-17 14:27:27 UTC
+
+# Who shared it
+item.created_by.display_name # => "Someone Else"
+item.created_by.email_address # => "outlook_64E5DD3210FD6004@outlook.com"
+item.last_modified_by.display_name # => "Someone Else"
+
+# The underlying drive item (with file?, folder?, mime_type, shared?, etc.)
+item.remote_item.file? # => true
+item.remote_item.shared? # => true
+```
+
+Use `shared_list.next_page?` and `shared_list.next_token` to paginate when there are many items.
+
 ### Get Permissions for a single Drive Item
 
 ```rb
@@ -86,10 +147,9 @@ Microsoft Graph API [batch](https://learn.microsoft.com/en-us/graph/json-batchin
 drive_item_list = client.delta(drive_id: drive.id)
 shared_items = drive_item_list.items.select(&:shared?)
 
-permission_batch = client.batch_permissions(item_ids: shared_items.map(&:id))
-
-# Under the hood, this will batch the shared_items into batches of 20 (the max Microsoft allows on their batch endpoint)
-# and returns an aggregated result.
+permissions = client.batch_permissions(item_ids: shared_items.map(&:id))
+# Returns a flat array of MicroslopOneDrive::Permission (batches of 20 are made under the hood).
+permissions.each { |p| puts "#{p.audience.display_name}: #{p.role}" }
 ```
 
 ## Contributing

data/lib/microslop_one_drive/batch/batch_response.rb

@@ -0,0 +1,15 @@
+module MicroslopOneDrive
+  module Batch
+    class BatchResponse
+      attr_reader :responses
+
+      def initialize
+        @responses = []
+      end
+
+      def add_response(response)
+        @responses << response
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/batch/response.rb

@@ -0,0 +1,18 @@
+module MicroslopOneDrive
+  module Batch
+    class Response
+      attr_reader :id, :status, :headers, :body
+
+      def initialize(response_hash)
+        @id = response_hash.fetch("id")
+        @status = response_hash.fetch("status")
+        @headers = response_hash.fetch("headers")
+        @body = response_hash.fetch("body")
+      end
+
+      def success?
+        @status.between?(200, 299)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/client.rb

@@ -3,7 +3,7 @@ require "json"
 module MicroslopOneDrive
   class Client
     BASE_URL = "https://graph.microsoft.com/v1.0".freeze
-    BATCH_REQUEST_LIMIT = 20.freeze
+    BATCH_REQUEST_LIMIT = 20 # This is set by Microsoft
 
     # @param access_token [String] OAuth access token for Microsoft Graph.
     # @param logger [Object, nil] Optional logger (e.g. Rails.logger) that responds to +#info+, +#debug+, +#warn+, +#error+.
@@ -25,30 +25,41 @@ module MicroslopOneDrive
     def me
       response = get(path: "me", query: {})
       handle_error(response) unless response.success?
-      MicroslopOneDrive::User.new(response.parsed_response)
+      MicroslopOneDrive::Deserializers::UserDeserializer.create_from_hash(response.parsed_response)
     end
 
-    # Gets all Drives the current user has access to.
+    # Gets a Drive.
     #
-    # NOTE: This will include some internal Microsoft drives that aren't real drives, such as AI, Face scans, and other
-    # shitty things.
+    # If no drive_id is provided, the current User's default Drive will be returned, else, the specific Drive identified
+    # by the drive_id will be returned.
     #
-    # @return [MicroslopOneDrive::DriveList]
-    def drives
-      response = get(path: "me/drives", query: {})
+    # From the docs:
+    #
+    # > Most users will only have a single Drive resource.
+    # > Groups and Sites may have multiple Drive resources available.
+    #
+    # @param drive_id [String, nil] The ID of the Drive to get. If not provided, the current User's default Drive will
+    # be returned.
+    #
+    # @return [MicroslopOneDrive::Drive]
+    def drive(drive_id: nil)
+      url = drive_id.nil? ? "me/drive" : "me/drives/#{drive_id}"
+      response = get(path: url, query: {})
+
       handle_error(response) unless response.success?
-      MicroslopOneDrive::DriveList.new(response.parsed_response)
+      MicroslopOneDrive::Deserializers::DriveDeserializer.create_from_hash(response.parsed_response)
     end
 
-    # Gets a specific Drive by its ID.
+    # Gets ALL Drives the current user has access to.
     #
-    # @param drive_id [String] The ID of the Drive to get.
+    # NOTE: This will include some internal Microsoft drives that aren't real drives, such as AI, Face scans, and other
+    # shitty things.
     #
-    # @return [MicroslopOneDrive::Drive]
-    def drive(drive_id:)
-      response = get(path: "me/drives/#{drive_id}", query: {})
+    # @return [MicroslopOneDrive::DriveList]
+    def all_drives
+      response = get(path: "me/drives", query: {})
       handle_error(response) unless response.success?
-      MicroslopOneDrive::Drive.new(response.parsed_response)
+      MicroslopOneDrive::ListResponses::DriveList.new(response.parsed_response)
     end
 
     # Asks if a Drive exists by its ID.
@@ -61,24 +72,31 @@ module MicroslopOneDrive
       response.success?
     end
 
-    # Gets a specific DriveItem (folder or file) by its ID.
+    # Gets a specific DriveItem (folder or file)
     #
+    # @param drive_id [String, nil] The ID of the Drive to get the Drive Item from. If not provided, the current User's
+    # default Drive will be used.
     # @param item_id [String] The ID of the Drive Item to get.
     #
     # @return [MicroslopOneDrive::DriveItem]
-    def drive_item(item_id:)
-      response = get(path: "me/drive/items/#{item_id}", query: {})
+    def drive_item(item_id:, drive_id: nil)
+      url = drive_id.nil? ? "me/drive/items/#{item_id}" : "me/drives/#{drive_id}/items/#{item_id}"
+      response = get(path: url, query: {})
+
       handle_error(response) unless response.success?
-      MicroslopOneDrive::DriveItem.new(response.parsed_response)
+      MicroslopOneDrive::Deserializers::DriveItemDeserializer.create_from_hash(response.parsed_response)
     end
 
     # Asks if a DriveItem (folder or file) exists by its ID.
     #
+    # @param drive_id [String, nil] The ID of the Drive to check the Drive Item in. If not provided, the current User's
+    # default Drive will be used.
     # @param item_id [String] The ID of the Drive Item to check.
     #
     # @return [Boolean]
-    def item_exists?(item_id:)
-      response = get(path: "me/drive/items/#{item_id}", query: {})
+    def drive_item_exists?(item_id:, drive_id: nil)
+      url = drive_id.nil? ? "me/drive/items/#{item_id}" : "me/drives/#{drive_id}/items/#{item_id}"
+      response = get(path: url, query: {})
 
       return false if response.code == 404
       return true if response.success?
@@ -86,33 +104,58 @@ module MicroslopOneDrive
       handle_error(response)
     end
 
-    # Gets a delta of changes to a Drive.
+    # Gets a delta of changes in a Drive.
     #
-    # @param drive_id [String] The ID of the Drive to get the delta of.
-    # @param token [String] The token to use for the delta. If not provided, the initial delta will be returned.
+    # @param drive_id [String, nil] The ID of the Drive to get the delta of. If not provided, the current User's default
+    # Drive will be used.
+    # @param token [String, nil] The token to use for the delta. If not provided, the initial delta will be returned.
     #
     # @return [MicroslopOneDrive::DriveItemList]
-    def delta(drive_id:, token: nil)
-      response = get(path: "me/drives/#{drive_id}/root/delta", query: {token: token})
+    def delta(drive_id: nil, token: nil)
+      url = drive_id.nil? ? "me/drive/root/delta" : "me/drives/#{drive_id}/root/delta"
+      response = get(path: url, query: {token: token})
+      handle_error(response) unless response.success?
+      MicroslopOneDrive::ListResponses::DriveItemList.new(response.parsed_response)
+    end
+
+    # Gets the Drive Items shared with the current user.
+    #
+    # @return [MicroslopOneDrive::SharedWithMeList]
+    def shared_with_me
+      response = get(path: "me/drive/sharedWithMe")
       handle_error(response) unless response.success?
-      MicroslopOneDrive::DriveItemList.new(response.parsed_response)
+      MicroslopOneDrive::ListResponses::SharedWithMeList.new(response.parsed_response)
     end
 
-    # Gets the permissions for a DriveItem (folder or file).
+    # Gets the permissions for a DriveItem (folder or file) in a Drive.
     #
+    # @param drive_id [String, nil] The ID of the Drive to get the permissions of. If not provided, the current User's
+    # default Drive will be used.
     # @param item_id [String] The ID of the Drive Item to get the permissions of.
     #
     # @return [MicroslopOneDrive::PermissionList]
-    def permissions(item_id:)
-      response = get(path: "me/drive/items/#{item_id}/permissions", query: {})
+    def permissions(item_id:, drive_id: nil)
+      url = if drive_id.nil?
+              "me/drive/items/#{item_id}/permissions"
+            else
+              "me/drives/#{drive_id}/items/#{item_id}/permissions"
+            end
+
+      response = get(path: url, query: {})
 
       if response.code == 404
-        return MicroslopOneDrive::PermissionList.new(drive_item_id: item_id, parsed_response: { "value" => [] })
+        return MicroslopOneDrive::ListResponses::PermissionList.new(
+          drive_item_id: item_id,
+          parsed_response: {"value" => []}
+        )
       end
 
       handle_error(response) unless response.success?
 
-      MicroslopOneDrive::PermissionList.new(drive_item_id: item_id, parsed_response: response.parsed_response)
+      MicroslopOneDrive::ListResponses::PermissionList.new(
+        drive_item_id: item_id,
+        parsed_response: response.parsed_response
+      )
     end
 
     # Gets the permissions for multiple Drive Items.
@@ -122,16 +165,21 @@ module MicroslopOneDrive
     #
     # See: https://learn.microsoft.com/en-us/graph/json-batching
     #
+    # @param drive_id [String, nil] The ID of the Drive to get the permissions of. If not provided, the current User's
+    # default Drive will be used.
     # @param item_ids [Array<String>] The IDs of the Drive Items to get the permissions of.
     #
     # @return [Array<MicroslopOneDrive::Permission>]
-    def batch_permissions(item_ids:)
-      requests = item_ids.map { |item_id| { id: item_id, method: "GET", url: "/me/drive/items/#{item_id}/permissions" } }
+    def batch_permissions(item_ids:, drive_id: nil)
+      requests = build_batch_permissions_requests(item_ids: item_ids, drive_id: drive_id)
       batch_response = batch(requests: requests)
       successful_responses = batch_response.responses.select(&:success?)
 
-      permission_lists = successful_responses.map do |response|
-        MicroslopOneDrive::PermissionList.new(drive_item_id: response.id, parsed_response: response.body)
+      permission_lists = successful_responses.map do
+        MicroslopOneDrive::ListResponses::PermissionList.new(
+          drive_item_id: it.id,
+          parsed_response: it.body
+        )
       end
 
       permission_lists.flat_map(&:permissions)
@@ -149,18 +197,18 @@ module MicroslopOneDrive
     #
     # @return [MicroslopOneDrive::BatchResponse]
     def batch(requests:)
-      batch_response = MicroslopOneDrive::BatchResponse.new
+      batch_response = MicroslopOneDrive::Batch::BatchResponse.new
 
       # No requests, so simply return an empty batch response:
       return batch_response if requests.empty?
 
       batches = requests.each_slice(BATCH_REQUEST_LIMIT).to_a
-      batches.each do |batch|
-        response = post(path: "$batch", body: { requests: batch }.to_json)
+      batches.each do
+        response = post(path: "$batch", body: {requests: it}.to_json)
         handle_error(response) unless response.success?
         new_responses = response.parsed_response.fetch("responses", [])
-        new_responses.each do |new_response_hash|
-          batch_response.add_response(MicroslopOneDrive::Response.new(new_response_hash))
+        new_responses.each do
+          batch_response.add_response(MicroslopOneDrive::Batch::Response.new(it))
         end
       end
 
@@ -169,6 +217,14 @@ module MicroslopOneDrive
 
     private
 
+    def build_batch_permissions_requests(item_ids:, drive_id: nil)
+      if drive_id.nil?
+        item_ids.map { {id: it, method: "GET", url: "/me/drive/items/#{it}/permissions"} }
+      else
+        item_ids.map { {id: it, method: "GET", url: "/me/drives/#{drive_id}/items/#{it}/permissions"} }
+      end
+    end
+
     def get(path:, query: {})
       url = "#{BASE_URL}/#{path}"
 
@@ -200,7 +256,7 @@ module MicroslopOneDrive
       @logger.info "==================== START MicroslopOneDrive #{method} #{url} ===================="
       @logger.info "Request method: #{method}"
       @logger.info "Request url: #{url}"
-      @logger.info "Request query: #{query.inspect}" if query && query.any?
+      @logger.info "Request query: #{query.inspect}" if query&.any?
       @logger.info "Request body: #{body.inspect}" if body
     end
 

data/lib/microslop_one_drive/deserializers/drive_deserializer.rb

@@ -0,0 +1,57 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class DriveDeserializer
+      # Creates a new Drive object from a hash.
+      #
+      # @param drive_hash [Hash] The hash to create the Drive object from.
+      # @return [MicroslopOneDrive::Drive] The created Drive object.
+      def self.create_from_hash(drive_hash)
+        drive_hash = Utils.deep_symbolize_keys(drive_hash)
+
+        created_by = build_created_by(drive_hash)
+        last_modified_by = build_last_modified_by(drive_hash)
+        owner = build_owner(drive_hash)
+
+        Drive.new(
+          id: drive_hash.fetch(:id, nil),
+          name: drive_hash.fetch(:name, nil),
+          description: drive_hash.fetch(:description, nil),
+          web_url: drive_hash.fetch(:webUrl, nil),
+          drive_type: drive_hash.fetch(:driveType, nil),
+          created_date_time: Utils.safe_parse_time(drive_hash.fetch(:createdDateTime, nil)),
+          last_modified_date_time: Utils.safe_parse_time(drive_hash.fetch(:lastModifiedDateTime, nil)),
+          created_by: created_by,
+          last_modified_by: last_modified_by,
+          owner: owner,
+          quota: QuotaDeserializer.create_from_hash(drive_hash.fetch(:quota, {}))
+        )
+      end
+
+      def self.build_created_by(drive_hash)
+        created_by_hash = drive_hash.dig(:createdBy, :user)
+
+        return unless created_by_hash
+
+        UserDeserializer.create_from_hash(created_by_hash)
+      end
+
+      def self.build_last_modified_by(drive_hash)
+        last_modified_by_hash = drive_hash.dig(:lastModifiedBy, :user)
+
+        return unless last_modified_by_hash
+
+        UserDeserializer.create_from_hash(last_modified_by_hash)
+      end
+
+      def self.build_owner(drive_hash)
+        owner_hash = drive_hash.dig(:owner, :user)
+
+        return unless owner_hash
+
+        UserDeserializer.create_from_hash(owner_hash)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/deserializers/drive_item_deserializer.rb

@@ -0,0 +1,67 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class DriveItemDeserializer
+      # Creates a new DriveItem object from a hash.
+      #
+      # @param drive_item_hash [Hash] The hash to create the DriveItem object from.
+      # @return [MicroslopOneDrive::DriveItem] The created DriveItem object.
+      def self.create_from_hash(drive_item_hash)
+        drive_item_hash = Utils.deep_symbolize_keys(drive_item_hash)
+
+        parameters = build_parameters(drive_item_hash)
+
+        root = drive_item_hash.key?(:root) && parameters[:file_or_folder] == :folder
+
+        if root
+          RootFolder.new(**parameters)
+        elsif parameters[:file_or_folder] == :file
+          File.new(**parameters)
+        elsif parameters[:file_or_folder] == :folder
+          Folder.new(**parameters)
+        else
+          DriveItem.new(**parameters)
+        end
+      end
+
+      def self.build_parameters(drive_item_hash)
+        file_or_folder = drive_item_hash.key?(:file) ? :file : :folder
+        mime_type = build_mime_type(file_or_folder, drive_item_hash)
+        parent_reference = build_parent_reference(drive_item_hash)
+
+        {
+          id: drive_item_hash.fetch(:id, nil),
+          name: drive_item_hash.fetch(:name, nil),
+          download_url: drive_item_hash.fetch(:"@microsoft.graph.downloadUrl", nil),
+          web_url: drive_item_hash.fetch(:webUrl, nil),
+          size: drive_item_hash.fetch(:size, nil),
+          created_date_time: Utils.safe_parse_time(drive_item_hash.fetch(:createdDateTime, nil)),
+          last_modified_date_time: Utils.safe_parse_time(drive_item_hash.fetch(:lastModifiedDateTime, nil)),
+          e_tag: drive_item_hash.fetch(:eTag, nil),
+          c_tag: drive_item_hash.fetch(:cTag, nil),
+          file_or_folder: file_or_folder,
+          mime_type: mime_type,
+          is_deleted: drive_item_hash.dig(:deleted, :state) == "deleted",
+          is_shared: drive_item_hash.key?(:shared),
+          parent_reference: parent_reference
+        }
+      end
+
+      def self.build_mime_type(file_or_folder, drive_item_hash)
+        if file_or_folder == :file
+          drive_item_hash.dig(:file, :mimeType)
+        else
+          MicroslopOneDrive::DriveItem::DIRECTORY_MIME_TYPE
+        end
+      end
+
+      def self.build_parent_reference(drive_item_hash)
+        parent_reference_hash = drive_item_hash.fetch(:parentReference, nil)
+        return unless parent_reference_hash
+
+        ParentReferenceDeserializer.create_from_hash(parent_reference_hash)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/deserializers/parent_reference_deserializer.rb

@@ -0,0 +1,20 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class ParentReferenceDeserializer
+      def self.create_from_hash(parent_reference_hash)
+        parent_reference_hash = Utils.deep_symbolize_keys(parent_reference_hash)
+
+        ParentReference.new(
+          drive_type: parent_reference_hash.fetch(:driveType, nil),
+          drive_id: parent_reference_hash.fetch(:driveId, nil),
+          id: parent_reference_hash.fetch(:id, nil),
+          name: parent_reference_hash.fetch(:name, nil),
+          path: parent_reference_hash.fetch(:path, nil),
+          site_id: parent_reference_hash.fetch(:siteId, nil)
+        )
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/deserializers/quota_deserializer.rb

@@ -0,0 +1,24 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class QuotaDeserializer
+      # Creates a new Quota object from a hash.
+      #
+      # @param quota_hash [Hash] The hash to create the Quota object from.
+      # @return [MicroslopOneDrive::Quota] The created Quota object.
+      def self.create_from_hash(quota_hash)
+        quota_hash = Utils.deep_symbolize_keys(quota_hash)
+
+        Quota.new(
+          deleted: quota_hash.fetch(:deleted, nil),
+          remaining: quota_hash.fetch(:remaining, nil),
+          state: quota_hash.fetch(:state, nil),
+          total: quota_hash.fetch(:total, nil),
+          used: quota_hash.fetch(:used, nil),
+          upgrade_available: quota_hash.dig(:storagePlanInformation, :upgradeAvailable)
+        )
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/deserializers/shared_with_me_item_deserializer.rb

@@ -0,0 +1,48 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class SharedWithMeItemDeserializer
+      def self.create_from_hash(shared_with_me_item_hash)
+        shared_with_me_item_hash = Utils.deep_symbolize_keys(shared_with_me_item_hash)
+
+        created_by = build_created_by(shared_with_me_item_hash)
+        last_modified_by = build_last_modified_by(shared_with_me_item_hash)
+        remote_item = build_remote_item(shared_with_me_item_hash)
+
+        SharedWithMeItem.new(
+          id: shared_with_me_item_hash.fetch(:id, nil),
+          name: shared_with_me_item_hash.fetch(:name, nil),
+          web_url: shared_with_me_item_hash.fetch(:webUrl, nil),
+          size: shared_with_me_item_hash.fetch(:size, nil),
+          last_modified_date_time: Utils.safe_parse_time(shared_with_me_item_hash.fetch(:lastModifiedDateTime, nil)),
+          created_date_time: Utils.safe_parse_time(shared_with_me_item_hash.fetch(:createdDateTime, nil)),
+          created_by: created_by,
+          last_modified_by: last_modified_by,
+          remote_item: remote_item
+        )
+      end
+
+      def self.build_created_by(shared_with_me_item_hash)
+        created_by_hash = shared_with_me_item_hash.dig(:createdBy, :user)
+        return unless created_by_hash
+
+        UserDeserializer.create_from_hash(created_by_hash)
+      end
+
+      def self.build_last_modified_by(shared_with_me_item_hash)
+        last_modified_by_hash = shared_with_me_item_hash.dig(:lastModifiedBy, :user)
+        return unless last_modified_by_hash
+
+        UserDeserializer.create_from_hash(last_modified_by_hash)
+      end
+
+      def self.build_remote_item(shared_with_me_item_hash)
+        remote_item_hash = shared_with_me_item_hash.fetch(:remoteItem, {})
+        return unless remote_item_hash
+
+        DriveItemDeserializer.create_from_hash(remote_item_hash)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/deserializers/user_deserializer.rb

@@ -0,0 +1,29 @@
+require "microslop_one_drive/utils"
+
+module MicroslopOneDrive
+  module Deserializers
+    class UserDeserializer
+      # Creates a new User object from a hash.
+      #
+      # @param user_hash [Hash] The hash to create the User object from.
+      # @return [MicroslopOneDrive::User] The created User object.
+      def self.create_from_hash(user_hash)
+        user_hash = Utils.deep_symbolize_keys(user_hash)
+
+        User.new(
+          id: user_hash.fetch(:id, nil),
+          principal_name: user_hash.fetch(:userPrincipalName, nil),
+          display_name: user_hash.fetch(:displayName, nil),
+          surname: user_hash.fetch(:surname, nil),
+          given_name: user_hash.fetch(:givenName, nil),
+          preferred_language: user_hash.fetch(:preferredLanguage, nil),
+          mail: user_hash.fetch(:mail, nil) || user_hash.fetch(:email, nil),
+          mobile_phone: user_hash.fetch(:mobilePhone, nil),
+          job_title: user_hash.fetch(:jobTitle, nil),
+          office_location: user_hash.fetch(:officeLocation, nil),
+          business_phones: user_hash.fetch(:businessPhones, [])
+        )
+      end
+    end
+  end
+end