rails g graphql:mutation create_topic
rails g graphql:mutation create_reply
rails g graphql:mutation create_like

module Mutations
  class CreateTopic < BaseMutation
    # just like queries, mutations return certain fields
    # in this case, the mutation returns a list of strings which are potential errors
    # and the topic that was created if the creation was successful
    field :errors, [String], null: false
    field :topic, Types::TopicType, null: true

    # mutations also take arguments, very similar to the way queries can take arguments
    argument :user_id, ID, required: true
    argument :title, String, required: true
    argument :content, String, required: true


    # Unlike queries, mutations must have a resolve method to tell
    # GraphQL what to do with the mutation and the arguments it receives.
    def resolve(title:, content:, user_id:)
      # In this case, we will create a new topic.
      topic = Topic.new(title: title, content: content, user_id: user_id)
      if topic.save
        {
          topic: topic,
          errors: []
        }
      else
        {
          topic: nil,
          errors: topic.errors.full_messages
        }
      end
    end
  end
end

module Mutations
  class CreateReply < BaseMutation
    # As with create_topic, we have fields, arguments and a resolve method
    field :errors, [String], null: false
    field :reply, Types::ReplyType, null: false

    # We need to give the pieces of the polymorphic info that it needs to
    # properly construct the association
    argument :post_id, ID, required: true
    # post_type tells Rails what kind of model to look for.
    argument :post_type, String, required: true

    argument :user_id, ID, required: true
    argument :content, String, required: true

    def resolve(post_id:, user_id:, content:, post_type:)
      # Use the Rails method `constantize` to turn a string into a constant
      # which we know should refer to an ActiveRecord model, allowing us to run
      # the ActiveRecord method `find_by` to get the correct object with that type
      type = post_type.constantize
      post = type.find_by(id: post_id)
      reply = Reply.new(content: content, user_id: user_id, post: post)
      if reply.save
        {
          reply: reply,
          errors: []
        }
      else
        {
          reply: nil,
          errors: reply.errors.full_messages
        }
      end
    end
  end
end

rails g controller users create

# app/controllers/users_controller.rb
class UsersController < ApplicationController

    def create
        user = User.new(user_params)

        if user.save
            render json: user_json(user)
        else
            render json: {
                message: 'Failed to create user',
                errors: user.errors.full_messages
            }
        end
    end


    private

    # Use strong parameters to prevent any unwanted parameters from getting through.
    # The password confirmation field is required to allow BCrypt to properly hash the password.
    def user_params
        params.require(:user).permit(:name, :username, :email, :password, :password_confirmation)
    end

    # Turns a user model object into a hash which can be converted to json. Maybe
    # not necessary in a controller this small, but certainly necessary in a larger project.
    def user_json(user)
        user.as_json(only: [:id, :name, :username, :email])
    end
end

rails g controller sessions create

# app/controllers/sessions_controller.rb
class SessionsController < ApplicationController

    def create
        # find the user by the username included in the parameters
        user = User.find_by(username: session_params[:username])
        # If the user exists, and can be authenticated with the given password, generate a token 
        # for the session and return it.
        if user && user.authenticate(session_params[:password])
            # Generate the token based on the user’s id. Use the value of JWT_SECRET in 
            # the `.env` file.
            token = JWT.encode({user_id: user.id}, ENV['JWT_SECRET'])
            render json: {token: token, user_id: user.id}
        else
            render json: {message: "Incorrect username or password"}
        end
    end

    private

    # Use strong parameters to make sure we only get a username and password.
    def session_params
        params.require(:session).permit(:username, :password)
    end
end

rake secret

JWT_SECRET=<rake output>

# app/controllers/application_controller.rb

# This error is used below to specify that a session is not authenticated
class AuthenticationError < StandardError

end

class ApplicationController < ActionController::API
    def current_user
        # Authentication setting the `Access-Token` header to the result of 
        # the create session route
        token = request.headers['Access-Token']
        raise AuthenticationError if token.nil?
        # Decodes the JWT token and returns only the user id from it.
        user_id = JWT.decode(token, ENV['JWT_SECRET'])[0]['user_id']
        @user = User.find_by(id: user_id)
    end
end

# app/controllers/graphql_controller.rb
class GraphqlController < ApplicationController

  def execute
    current_user
    variables = ensure_hash(params[:variables])
    ...
  end
  ...
end