mangadex 5.4.9 → 5.4.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 498b3099b585f68a83983fd391d7b379ffa6b37ad41073d14c6b44d426691e5a
-  data.tar.gz: ba5b94653c90682241b2d98c9652fa3614ae7c1fc9b6a735919cea17aa7ab0b4
+  metadata.gz: 29160bf116b71505a8b9697dd7c3940054e7f0b7a837c4f34470b5bff896879c
+  data.tar.gz: a245fdd04997fbc3ce6db61d2b3ab831d80df24db6431efc8a9a516a55111617
 SHA512:
-  metadata.gz: 8afe63e8dcd7612a0f85b86a5f9b393f12401c6fdbc21118e490739b6ae5a77790f34f323daa32b9ef4bd9b70be35f7882266b284c2ca7a02acb97992f31c262
-  data.tar.gz: 2cfa10681bad8af8a1968cc528e923d82d9808948d3f174111e65b1a8ffaf6792febc717d5c5cef311c83331c75c0508f9dfde2e6119621e94eb1a954d5aa836
+  metadata.gz: 0234ba9078a3927eecc7bf84acfde344612c4b4ae3ae0b8b30074daf320d874540bf2dfd4a4e82b7b23cfa534ed919271fa398ad22d0bdd8045ed6c2b2c5d1b6
+  data.tar.gz: 4ac033f5cfa89f851d2e8842b50b2bf487b5310c7c92391e0466bf6183a0b0fee1be1bb0b97765e6b8cf4597285edf8c84f7ee38f9892d7592d3cd4171180199

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mangadex (5.3.3.4)
+    mangadex (5.4.11)
       activesupport (~> 6.1)
       psych (~> 4.0.1)
       rest-client (~> 2.1)
@@ -32,9 +32,9 @@ GEM
     i18n (1.8.10)
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
-    mime-types (3.3.1)
+    mime-types (3.4.1)
       mime-types-data (~> 3.2015)
-    mime-types-data (3.2021.0901)
+    mime-types-data (3.2022.0105)
     minitest (5.14.4)
     mustermann (1.1.1)
       ruby2_keywords (~> 0.0.1)
@@ -42,7 +42,8 @@ GEM
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    psych (4.0.1)
+    psych (4.0.3)
+      stringio
     public_suffix (4.0.6)
     rack (2.2.3)
     rack-protection (2.1.0)
@@ -82,9 +83,10 @@ GEM
     smart_properties (1.16.3)
     sorbet (0.5.9152)
       sorbet-static (= 0.5.9152)
-    sorbet-runtime (0.5.9211)
+    sorbet-runtime (0.5.9542)
     sorbet-static (0.5.9152-universal-darwin-20)
     sorbet-static (0.5.9152-x86_64-linux)
+    stringio (3.0.1)
     tilt (2.0.10)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)

data/README.md

@@ -23,7 +23,341 @@ Or install it yourself as:
 ## Usage
 
 Please note that I tried my best to follow Mangadex's naming conventions for [their documentation](https://api.mangadex.org). Track the progress [here in an issue](https://github.com/thedrummeraki/mangadex/issues/5).
-To find out how to use the gem, you're welcome to [check this out](lib/mangadex).
+Although a work a in progress, feel free to [check this out](lib/mangadex).
+
+### Basic Usage
+
+Here's a couple of cool things you can do with the gem:
+
+#### Get a list of manga
+
+```ruby
+response = Mangadex::Manga.list
+manga = response.data # Array of #<Mangadex::Manga>
+```
+
+#### Get a manga by id, with cover_art
+
+```ruby
+manga_id = 'd86cf65b-5f6c-437d-a0af-19a31f94ec55'
+response = Mangadex::Manga.get(manga_id, includes: :cover_art)
+entity = response.data # Object of #<Mangadex::Manga>
+
+# Original size
+entity.cover_art.image_url(size: :original)
+entity.cover_art.image_url(size: :medium)
+entity.cover_art.image_url(size: :small) # default size
+```
+
+#### Get a manga's chapter list, ordered by volume and chapter number
+
+```ruby
+manga_id = 'd86cf65b-5f6c-437d-a0af-19a31f94ec55'
+manga_response = Mangadex::Manga.get(manga_id, includes: :cover_art)
+entity = manga_response.data
+
+chapter_response = Mangadex::Chapter.list(
+  manga: entity.id,
+  order: { volume: 'asc', chapter: 'asc' },
+  translated_language: 'en',
+)
+chapters = chapter_response.data # Array of #<Mangadex::Chapter>
+```
+
+#### Get a chapter's pages
+
+```ruby
+chapter_id = 'e7bb1892-7f83-4a89-bccc-0d6d403a85fc'
+chapter = Mangadex::Chapter.get(chapter_id).data
+pages = chapter.page_urls # Data saver true by default
+```
+
+#### Search for manga by title
+
+```ruby
+response = Mangadex::Manga.list(title: 'Ijiranaide nagatoro')
+found_manga = response.data
+```
+
+#### Authenticate
+
+```ruby
+Mangadex::Auth.login(username: 'username', password: 'password') do |user|
+  # `user` is of type Mangadex::Api::User
+  puts(user.mangadex_user_id)
+  puts(user.session)
+  puts(user.refresh)
+  puts(user.session_valid_until)
+end
+```
+
+You can access the authenticated user by using context:
+
+```ruby
+user = Mangadex.context.user
+```
+
+#### Refresh the user's token
+
+```ruby
+Mangadex.context.user.refresh_session! do |user|
+  # `user` is of type Mangadex::Api::User
+  puts(user.mangadex_user_id)
+  puts(user.session)
+  puts(user.refresh)
+  puts(user.session_valid_until)
+end
+```
+
+#### Create an public MDList, add then remove a manga
+
+```ruby
+Mangadex::Auth.login(...)
+response = Mangadex::CustomList.create(name: 'My awesome list!', visibility: 'public')
+custom_list = response.data
+
+manga_id = 'd86cf65b-5f6c-437d-a0af-19a31f94ec55'
+# Add the manga
+custom_list.add_manga(manga_id)
+
+# Remove the manga
+custom_list.remove_manga(manga_id)
+
+# Get manga list
+manga = custom_list.manga_details.data # Array of #<Mangadex::Manga>
+```
+
+### Are you on Rails?
+
+This gem tries its best to be agnostic to popular frameworks like Rails. Here's however a couple of things to can do to integrate the gem to your project.
+
+First, add the gem to your `Gemfile`.
+
+#### Configurating the gem
+
+Create a initilizer file to `config/initializers/mangadex.rb`. You can add the following:
+
+```ruby
+Mangadex.configure do |config|
+  # Override the default content ratings
+  config.default_content_ratings = %w(safe suggestive)
+
+  # Override the Mangadex API URL (ie: proxy)
+  config.mangadex_url = 'https://my-proxy-mangadex-url.com'
+end
+```
+
+#### Authenticate your users
+
+This could be useful if you want to support authentication. You will need to persist your user's session, refresh token and session expiry date.
+
+##### Persist the user information
+
+If you haven't done so, create your user.
+
+```ruby
+class CreateUsers < ActiveRecord::Migration[6.1]
+  def change
+    create_table :users do |t|
+      t.string :mangadex_user_id, null: false
+      t.string :username
+      t.string :session
+      t.string :refresh
+      t.datetime :session_valid_until
+
+      t.timestamps
+    end
+  end
+end
+
+```
+
+Already created your `User` class? Make sure it has all of the following:
+- `mangade_user_id`: ID used to identify your user on Mangadex
+- `username`: Your username
+- `session`: The session token (valid for 15 minutes)
+- `refresh`: The refresh token, used to refresh the session (valid for 1 month)
+- `session_valid_until`: The time `session` session expires at
+
+If anything is missing, create a migration.
+
+#### Authentication flow on the controller
+
+Add these methods to your controller's helper (ie: `ApplicationHelper`):
+
+```ruby
+module ApplicationHelper
+  def current_user
+    @current_user ||= User.find_by(id: session[:id])
+  end
+
+  def logged_in?
+    current_user.present?
+  end
+
+  def log_in(user)
+    # `user` is an instance of your `User` class
+    session[:id] = user.id6
+  end
+
+  def log_out
+    # Logout from Mangadex
+    Mangadex::Auth.logout
+
+    # Remove the session
+    session.delete(:id)
+  end
+end
+```
+
+First make sure `ApplicationController` includes the helper above
+
+```ruby
+class ApplicationController < ActionController::Base
+  include ApplicationHelper
+
+  # ...
+end
+```
+
+We recommend creating a controller for authentication. Here's how you can implement the login and logout actions:
+
+```ruby
+# app/controllers/session_controller.rb
+class SessionController < ApplicationController
+  # GET /login
+  def new
+    # render the login form
+  end
+
+  # POST /login
+  def create
+    username = params[:username]
+    password = params[:password]
+
+    # You can also use `email` instead of `username` to log in
+    user = Mangadex::Auth.login(username: username, password: password) do |mangadex_user|
+      # Find the user by mangadex user id (or initialize if it doesn't exist)
+      our_user = User.find_or_initialize_by(mangadex_user_id: mangadex_user.mangadex_user_id) do |new_user|
+        new_user.username = mangadex_user.data.username
+      end
+
+      # Update the session info data
+      our_user.session = mangadex_user.session
+      our_user.refresh = mangadex_user.refresh
+      our_user.session_valid_until = mangadex_user.session_valid_until
+
+      # ...then save the user
+      our_user.save!
+      our_user
+    end
+
+    # `user` will be an instance of your `User` class
+    # Now, we can log in then redirect to the root.
+    log_in(user)
+    redirect_to(root_path)
+  rescue Mangadex::Errors::AuthenticationError => error
+    # See https://api.mangadex.org/docs.html to learn more about errors
+    Rails.logger.error(error.response.errors)
+    
+    # Handle authentication errors here
+  end
+
+  # DELETE /logout
+  def destroy
+    log_out
+
+    redirect_to(root_path)
+  end
+end
+```
+
+Finally, add the routes.
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  get '/login' => 'session#new'
+  post '/login' => 'session#create'
+  delete '/logout' => 'session#destroy'
+end
+```
+
+#### Protected resources
+
+Here's an example of a controller that requires every action to be logged in. This is based on the steps above.
+
+```ruby
+class ProtectedController < ApplicationController
+  before_action :ensure_logged_in!
+
+  private
+
+  def ensure_logged_in!
+    return if logged_in?
+
+    redirect_to(login_path) # go to /login
+  end
+end
+```
+
+We're going with managing (list, create, show, edit, delete) MDLists (ie: custom lists). __We're not using strong params below to keep things simple, but you should, especially when mutating data (ie: creating and editing)__.
+
+```ruby
+class CustomListsController < ProtectedController
+  # GET /custom_list
+  def index
+    @custom_lists = Mangadex::CustomList.list
+  end
+
+  # GET /custom_list/new
+  def new
+    # new custom list form
+  end
+
+  # POST /custom_list
+  def create
+    @custom_list = Mangadex::CustomList.create(
+      name: params[:name],
+      visibility: params[:visibility],
+      manga: params[:manga], # Manga ID
+    )
+  end
+
+  # GET /custom_list/<id>
+  def show
+    @custom_list = Mangadex::CustomList.get(params[:id])
+  end
+
+  # GET /custom_list/<id>/edit
+  def edit
+    @custom_list = Mangadex::CustomList.get(params[:id])
+    # edit custom list form
+  end
+
+  # PUT /custom_list/<id>
+  # PATCH /custom_list/<id>
+  def update
+    # Note: when updating the custom list, be sure to pass in
+    # the current version number!
+    @custom_list = Mangadex::CustomList.update(
+      params[:id],
+      {
+        name: params[:name],
+        visibility: params[:visibility],
+        manga: params[:manga],
+        version: params[:version].to_i,
+      }
+    )
+  end
+
+  # DELETE /custom_list/<id>
+  def destroy
+    Mangadex::CustomList.delete(params[:id])
+  end
+end
+```
 
 ## Development
 

data/bin/console

@@ -3,16 +3,23 @@
 require "bundler/setup"
 require "mangadex"
 
-username, password, email = [
-  ENV['MD_USERNAME'],
-  ENV['MD_PASSWORD'],
-  ENV['MD_EMAIL'],
-]
+def try_logging_in
+  username, password, email = [
+    ENV['MD_USERNAME'],
+    ENV['MD_PASSWORD'],
+    ENV['MD_EMAIL'],
+  ]
 
-if (username || email) && password
-  Mangadex::Auth.login(username: username, email: email, password: password)
+  if (username || email) && password
+    Mangadex::Auth.login(username: username, email: email, password: password)
+  end
+rescue Mangadex::Errors::StandardError => e
+  puts e
+  false
 end
 
+try_logging_in
+
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 

data/docs/authentication.md

@@ -61,10 +61,7 @@ user.data
 
 ```ruby
 # Refreshes the tokens now (Boolean)
-user.refresh!
-
-# Refreshes the tokens if expired, then return user itself (Mangadex::Api::User)
-user.with_valid_session
+user.refresh_session!
 
 # Returns if user.session has expired (Boolean)
 user.session_expired?

data/lib/config.rb

@@ -4,11 +4,6 @@ module Mangadex
   class Config
     extend T::Sig
 
-    # Class used to persist users
-    # Must respond to: :session, :refresh, :mangadex_user_id
-    sig { returns(Class) }
-    attr_accessor :user_class
-
     # Persisting strategy. See Mangadex::Storage::Base for more details.
     sig { returns(Class) }
     attr_accessor :storage_class
@@ -16,16 +11,19 @@ module Mangadex
     sig { returns(T::Array[ContentRating]) }
     attr_accessor :default_content_ratings
 
+    sig { returns(String) }
+    attr_accessor :mangadex_url
+
     sig { void }
     def initialize
-      @user_class = Api::User
       @storage_class = Storage::Memory
       @default_content_ratings = ContentRating.parse(['safe', 'suggestive', 'erotica'])
+      @mangadex_url = 'https://api.mangadex.org'
     end
 
     sig { params(klass: Class).void }
     def user_class=(klass)
-      missing_methods = [:session, :refresh, :mangadex_user_id] - klass.instance_methods
+      missing_methods = [:session, :refresh, :mangadex_user_id] - klass.new.methods
       if missing_methods.empty?
         @user_class = klass
       else

data/lib/mangadex/api/user.rb

@@ -7,6 +7,13 @@ module Mangadex
       attr_accessor :mangadex_user_id, :session, :refresh, :session_valid_until
       attr_reader :data
 
+      SERIALIZABLE_KEYS = %i(
+        mangadex_user_id
+        session
+        refresh
+        session_valid_until
+      )
+
       sig { params(mangadex_user_id: String, session: T.nilable(String), refresh: T.nilable(String), data: T.untyped, session_valid_until: T.nilable(Time)).void }
       def initialize(mangadex_user_id:, session: nil, refresh: nil, data: nil, session_valid_until: nil)
         raise ArgumentError, 'Missing mangadex_user_id' if mangadex_user_id.to_s.empty?
@@ -18,10 +25,33 @@ module Mangadex
         @data = data
       end
 
+      # true: The tokens were successfully refreshed if the session expired
+      # false: Error: refresh token empty or could not refresh the token on the server
+      sig do
+        params(
+          block: T.nilable(
+            T.proc.params(arg0: User).returns(
+              T.untyped)
+            )
+          ).returns(T::Boolean)
+      end
+      def refresh_session(&block)
+        return true unless session_expired?
+
+        refresh_session!(&block)
+      end
+
       # true: The tokens were successfully refreshed
       # false: Error: refresh token empty or could not refresh the token on the server
-      sig { returns(T::Boolean) }
-      def refresh!
+      sig do
+        params(
+          block: T.nilable(
+            T.proc.params(arg0: User).returns(
+              T.untyped)
+            )
+          ).returns(T::Boolean)
+      end
+      def refresh_session!(&block)
         return false if refresh.nil?
 
         response = Mangadex::Internal::Request.post('/auth/refresh', payload: { token: refresh })
@@ -31,15 +61,11 @@ module Mangadex
         @refresh = response.dig('token', 'refresh')
         @session = response.dig('token', 'session')
 
-        true
-      end
+        if block_given?
+          yield(self)
+        end
 
-      sig { returns(User) }
-      def with_valid_session
-        session_expired? && refresh!
-        self
-      ensure
-        self
+        true
       end
 
       sig { returns(T::Boolean) }
@@ -65,6 +91,18 @@ module Mangadex
         !mangadex_user_id.nil? && !mangadex_user_id.strip.empty?
       end
 
+      sig { params(except: T.any(Symbol, T::Array[Symbol])).returns(Hash) }
+      def to_h(except: [])
+        except = Array(except).map(&:to_sym)
+        keys = SERIALIZABLE_KEYS.reject do |key|
+          except.include?(key)
+        end
+
+        keys.map do |key|
+          [key, send(key)]
+        end.to_h
+      end
+
       sig { params(mangadex_user_id: T.nilable(String)).returns(T.nilable(User)) }
       def self.from_storage(mangadex_user_id)
         return if mangadex_user_id.nil?
@@ -81,7 +119,7 @@ module Mangadex
             session: session,
             refresh: refresh,
             session_valid_until: session_valid_until,
-          ).with_valid_session
+          )
         else
           nil
         end

data/lib/mangadex/api/version_checker.rb

@@ -18,7 +18,7 @@ module Mangadex
         if version != Mangadex::Version::STRING
           warn(
             "[Warning] This gem is compatible with #{Mangadex::Version::STRING} but it looks like Mangadex is at #{version}",
-            "[Warning] Check out #{Mangadex::Internal::Request::BASE_URI} for more information.",
+            "[Warning] Check out #{Mangadex.configuration.mangadex_url} for more information.",
           )
         end
 

data/lib/mangadex/at_home.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Mangadex
+  class AtHome
+    extend T::Sig
+
+    sig { params(chapter_id: String).returns(T::Api::GenericResponse) }
+    def self.server(chapter_id)
+      Mangadex::Internal::Request.get(
+        "/at-home/server/#{chapter_id}",
+      )
+    end
+
+    sig { params(chapter_id: String, data_saver: T::Boolean).returns(T.nilable(T::Array[String])) }
+    def self.page_urls(chapter_id, data_saver: true)
+      response = self.server(chapter_id)
+      return if response.is_a?(Mangadex::Api::Response)
+
+      base_url = response['baseUrl']
+      chapter_data = response['chapter']
+      hash = chapter_data['hash']
+      source = data_saver ? chapter_data['dataSaver'] : chapter_data['data']
+      data_source = data_saver ? 'data-saver' : 'data'
+
+      source.map do |filename|
+        [base_url, data_source, hash, filename].join('/')
+      end
+    end
+  end
+end

data/lib/mangadex/auth.rb

@@ -3,8 +3,17 @@ module Mangadex
   class Auth
     extend T::Sig
 
-    sig { params(username: T.nilable(String), email: T.nilable(String), password: String).returns(T.nilable(Mangadex::Api::User)) }
-    def self.login(username: nil, email: nil, password: nil)
+    sig do
+      params(
+        username: T.nilable(String),
+        email: T.nilable(String),
+        password: String,
+        block: T.nilable(T.proc.returns(T.untyped))
+      ).returns(
+        T.nilable(T.untyped),
+      )
+    end
+    def self.login(username: nil, email: nil, password: nil, &block)
       args = { password: password }
       args.merge!(email: email) if email
       args.merge!(username: username) if username
@@ -18,6 +27,8 @@ module Mangadex
         }),
       )
 
+      session_valid_until = Time.now + (15 * 60)
+
       session = response.dig('token', 'session')
       refresh = response.dig('token', 'refresh')
 
@@ -28,12 +39,18 @@ module Mangadex
         session: session,
         refresh: refresh,
         data: mangadex_user.data,
+        session_valid_until: session_valid_until,
       )
-      return if user.session_expired?
+
+      user.persist
+      user
 
       Mangadex.context.user = user
 
-      user.persist
+      if block_given?
+        return yield(user)        
+      end
+
       user
     rescue Errors::UnauthorizedError => error
       raise Errors::AuthenticationError.new(error.response)
@@ -67,7 +84,7 @@ module Mangadex
 
     sig { returns(T::Boolean) }
     def self.refresh_token
-      !(Mangadex.context.user&.refresh!).nil?
+      !(Mangadex.context.user&.refresh_session!).nil?
     end
 
     private

data/lib/mangadex/chapter.rb

@@ -88,11 +88,9 @@ module Mangadex
       locale&.english_name
     end
 
-    sig { returns(T.nilable(String)) }
-    def preview_image_url
-      return if data_saver.empty?
-
-      "https://uploads.mangadex.org/data-saver/#{attributes.hash}/#{data_saver.first}"
+    sig { params(data_saver: T::Boolean).returns(T.nilable(T::Array[String])) }
+    def page_urls(data_saver: true)
+      Mangadex::AtHome.page_urls(id, data_saver: data_saver)
     end
 
     def as_json(*)

data/lib/mangadex/custom_list.rb

@@ -135,7 +135,8 @@ module Mangadex
 
     sig { params(args: T::Api::Arguments).returns(T.nilable(Mangadex::Api::Response[Manga])) }
     def manga_details(**args)
-      ids = mangas.map(&:id)
+      custom_list = Mangadex::CustomList.get(id).data
+      ids = custom_list.mangas.map(&:id)
       ids.any? ? Mangadex::Manga.list(**args.merge(ids: ids)) : nil
     end
 

data/lib/mangadex/internal/context.rb

@@ -18,7 +18,7 @@ module Mangadex
 
       sig { returns(T.nilable(Mangadex::Api::User)) }
       def user
-        @ignore_user ? nil : @user&.with_valid_session
+        @ignore_user ? nil : @user
       rescue Mangadex::Errors::UnauthorizedError
         warn("A user is present but not authenticated!")
         nil
@@ -29,7 +29,7 @@ module Mangadex
         @tags ||= Mangadex::Tag.list.data
       end
 
-      sig { params(user: T.nilable(T.any(Hash, Mangadex::Api::User, Mangadex::User)), block: T.proc.returns(T.untyped)).returns(T.untyped) }
+      sig { params(user: T.nilable(T.untyped), block: T.proc.returns(T.untyped)).returns(T.untyped) }
       def with_user(user, &block)
         temp_set_value("user", user) do
           yield
@@ -64,11 +64,12 @@ module Mangadex
             session: user[:session],
             refresh: user[:refresh],
           )
-        elsif user_object?(user)
+        elsif Mangadex::Internal::Context.user_object?(user)
           @user = Mangadex::Api::User.new(
             mangadex_user_id: user.mangadex_user_id.to_s,
             session: user.session,
             refresh: user.refresh,
+            session_valid_until: user.session_valid_until,
             data: user,
           )
         elsif user.nil?
@@ -113,18 +114,18 @@ module Mangadex
         end
       end
 
-      private
-
-      def user_object?(user)
+      def self.user_object?(user)
         return false if user.nil?
 
-        missing_methods = [:session, :refresh, :mangadex_user_id] - user.methods
+        missing_methods = [:session, :refresh, :mangadex_user_id, :save] - user.methods
         return true if missing_methods.empty?
 
         warn("Potential user object #{user} is missing #{missing_methods}")
         false
       end
 
+      private
+
       def temp_set_value(name, value, &block)
         setter_method_name = "#{name}="
 

data/lib/mangadex/internal/definition.rb

@@ -108,10 +108,11 @@ module Mangadex
               offset: { accepts: Integer },
               ids: { accepts: [String] },
               title: { accepts: String },
+              manga: { accepts: String },
               groups: { accepts: [String] },
               uploader: { accepts: [String], converts: converts(:to_a) },
               chapter: { accepts: [String], converts: converts(:to_a) },
-              translated_language: { accepts: String },
+              translated_language: { accepts: [String], converts: converts(:to_a) },
               original_language: { accepts: [String] },
               excluded_original_language: { accepts: [String] },
               content_rating: { accepts: %w(safe suggestive erotica pornographic), converts: converts(:to_a) },

data/lib/mangadex/internal/request.rb

@@ -7,7 +7,6 @@ require 'active_support/core_ext/hash/keys'
 module Mangadex
   module Internal
     class Request
-      BASE_URI = 'https://api.mangadex.org'
       ALLOWED_METHODS = %i(get post put delete).freeze
 
       attr_accessor :path, :headers, :payload, :method, :raw
@@ -51,7 +50,7 @@ module Mangadex
       end
 
       def run!(raw: false, auth: false)
-        payload_details = request_payload ? "Payload: #{request_payload}" : "{no-payload}"
+        payload_details = request_payload ? "Payload: #{sensitive_request_payload}" : "{no-payload}"
         puts("[#{self.class.name}] #{method.to_s.upcase} #{request_url} #{payload_details}")
 
         raise Mangadex::Errors::UserNotLoggedIn.new if auth && Mangadex.context.user.nil?
@@ -100,7 +99,7 @@ module Mangadex
 
       def request_url
         request_path = path.start_with?('/') ? path : "/#{path}"
-        "#{BASE_URI}#{request_path}"
+        "#{Mangadex.configuration.mangadex_url}#{request_path}"
       end
 
       def request_payload
@@ -108,12 +107,20 @@ module Mangadex
 
         JSON.generate(payload)
       end
+      
+      def sensitive_request_payload(sensitive_fields: %w(password token))
+        payload = JSON.parse(request_payload)
+        sensitive_fields.map(&:to_s).each do |field|
+          payload[field] = '[REDACTED]' if payload.key?(field)
+        end
+        JSON.generate(payload)
+      end
 
       def request_headers
         return headers if Mangadex.context.user.nil?
 
         headers.merge({
-          Authorization: Mangadex.context.user.with_valid_session.session,
+          Authorization: Mangadex.context.user.session,
         })
       end
 

data/lib/mangadex/internal/with_attributes.rb

@@ -31,7 +31,7 @@ module Mangadex
           self.name.split('::').last.underscore
         end
 
-        def from_data(data, related_type: nil)
+        def from_data(data, related_type: nil, source_obj: nil)
           base_class_name = self.name.gsub('::', '_')
           klass_name = self.name
           target_attributes_class_name = "#{base_class_name}_Attributes"
@@ -57,7 +57,7 @@ module Mangadex
           data = data.with_indifferent_access
 
           relationships = data['relationships']&.map do |relationship_data|
-            Relationship.from_data(relationship_data)
+            Relationship.from_data(relationship_data, MangadexObject.new(**data))
           end
 
           attributes = klass.new(**Hash(data['attributes']))
@@ -69,8 +69,11 @@ module Mangadex
             related_type: related_type,
           }
 
+          relationships = [source_obj].compact unless relationships.present?
           initialize_hash.merge!({relationships: relationships}) if relationships.present?
 
+          # binding.pry
+
           new(**initialize_hash)
         end
       end

data/lib/mangadex/manga.rb

@@ -70,12 +70,13 @@ module Mangadex
 
     sig { params(id: String, args: T::Api::Arguments).returns(T::Api::MangaResponse) }
     def self.view(id, **args)
+      to_a = Mangadex::Internal::Definition.converts(:to_a)
       Mangadex::Internal::Definition.must(id)
 
       Mangadex::Internal::Request.get(
         '/manga/%{id}' % {id: id},
         Mangadex::Internal::Definition.validate(args, {
-          includes: { accepts: Array },
+          includes: { accepts: Array, converts: to_a },
         })
       )
     end
@@ -126,9 +127,9 @@ module Mangadex
       )
     end
 
-    sig { params(status: String).returns(T::Api::GenericResponse) }
-    def self.all_reading_status(status)
-      args = { status: status }
+    sig { params(status: T.nilable(String)).returns(T::Api::GenericResponse) }
+    def self.all_reading_status(status = nil)
+      args = { status: status } if status.present?
 
       Mangadex::Internal::Request.get(
         '/manga/status',
@@ -165,6 +166,15 @@ module Mangadex
       )
     end
 
+    sig { params(id: T.any(T::Array[String], String), grouped: T::Boolean).returns(T::Api::GenericResponse) }
+    def self.read_markers(id, grouped: false)
+      Mangadex::Internal::Request.get(
+        '/manga/read',
+        { ids: Array(id), grouped: grouped },
+        auth: true,
+      )
+    end
+
     # Untested API endpoints
     sig { params(id: String, args: T::Api::Arguments).returns(T::Api::MangaResponse) }
     def self.update(id, **args)
@@ -202,5 +212,11 @@ module Mangadex
 
       ContentRating.new(attributes.content_rating)
     end
+
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[Chapter]) }
+    def chapters(**args)
+      chapter_args = args.merge({manga: id})
+      Chapter.list(**chapter_args)
+    end
   end
 end

data/lib/mangadex/relationship.rb

@@ -22,19 +22,24 @@ module Mangadex
     ).freeze
 
     class << self
-      def from_data(data)
+      # data: Relationship data
+      # source_obj: The object to witch the object belongs to
+      def from_data(data, source_obj = nil)
         data = data.with_indifferent_access
         klass = class_for_relationship_type(data['type'])
 
         if klass && data['attributes']&.any?
-          return klass.from_data(data, related_type: data['related'])
+          return klass.from_data(data, related_type: data['related'], source_obj: source_obj)
         end
 
+        relationships = [source_obj] if source_obj
+
         new(
           id: data['id'],
           type: data['type'],
           attributes: OpenStruct.new(data['attributes']),
           related: data['related'],
+          relationships: relationships,
         )
       end
 

data/lib/mangadex/scanlation_group.rb

@@ -17,6 +17,7 @@ module Mangadex
       :focused_language,
       :publish_delay,
       :inactive,
+      :manga_updates,
       :version,
       :created_at,
       :updated_at

data/lib/mangadex/types.rb

@@ -22,3 +22,6 @@ require_relative "report_reason"
 
 # Relationship
 require_relative "relationship"
+
+# At home
+require_relative "at_home"

data/lib/mangadex/version.rb

@@ -3,7 +3,7 @@ module Mangadex
   module Version
     MAJOR = "5"
     MINOR = "4"
-    TINY = "9"
+    TINY = "11"
     PATCH = nil
 
     STRING = [MAJOR, MINOR, TINY].compact.join('.')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mangadex
 version: !ruby/object:Gem::Version
-  version: 5.4.9
+  version: 5.4.11
 platform: ruby
 authors:
 - Akinyele Cafe-Febrissy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-18 00:00:00.000000000 Z
+date: 2022-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: psych
@@ -184,6 +184,7 @@ files:
 - lib/mangadex/api/user.rb
 - lib/mangadex/api/version_checker.rb
 - lib/mangadex/artist.rb
+- lib/mangadex/at_home.rb
 - lib/mangadex/auth.rb
 - lib/mangadex/author.rb
 - lib/mangadex/chapter.rb
@@ -261,7 +262,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: Your next favourite Ruby gem for interacting with Mangadex.org