Graphql Archives - Kpyxal Solutions LLP

Mutation in GRAPHQL

admin — Mon, 20 Feb 2023 16:04:27 +0000

In the world of GraphQL, queries and mutations play distinct but complementary roles.Specifically, While GraphQL queries are designed to perform read operations, mutations handle the task of modifying data. Essentially, a mutation allows you to create, update, or delete objects and fields, functioning similarly to POST, PUT, and DELETE requests in REST terminology. Moreover, Understanding the structure and function of mutations is crucial for effective data manipulation and application management. Therefore, In this context, let’s delve into the components that make up a Mutation in GRAPHQL and see how they contribute to its functionality.

Structure of a mutation

Mutations consist of several key elements:

First, you need the keyword ‘mutation.
An operation name for your local implementation. Consequently, this name is required if you include variables. On the other hand, it is optional.
The mutation name
The input object or attributes.In particular, Most mutations require an input object that contains data or individual attributes for the application server to process. However, on the other hand, some mutations, such as createEmptyCart, do not require an input object. In this particular case, therefore, the authorization token passed with the request provides the needed context.
The output object, which specifies which data the mutation returns.

Example of mutation graphql

Here in this example, we are, indeed, adding data to the database using a GraphQL mutation.

Step 1 :- You Create registration.php file





Step 2 :- create etc/module.xml file








    
        
            
            
        
    




Step 3 :- GraphQL queries are declared under etc/schema.graphqls



type Mutation {
    dataFormSubmit(input: FormInput!): FormOutput @resolver(class: "\\Kpyxal\\MutationGraphql\\Model\\Resolver\\FormDataSave") @doc(description:"Contact us form")
}

input FormInput {
    name: String @doc(description: "Get Name")
    number: String @doc(description: "Get Number")
    email: String @doc(description: "Get Email")
    password: String @doc(description: "Get Password")
    gender: Int @doc(description: "Get Gender")
    bdate: String @doc(description: "Get Birth Date")
}

type FormOutput {
   success_message: String @doc(description: "Success Message")
}




Explanation of graphql :-




type Mutation > declares Mutation operations of our module.



dataFormSubmit > name of our Mutation.



FormInput > it is input value and type.



FormOutput > declares output message.




Step 4 :- Create Resolver Class Model/Resolver/FormDataSave.php



_testRepository=$testRepository;
        $this->_testModel = $testInterface;
    }

    /**
     * @inheritdoc
     */
    public function resolve(
        Field $field,
        $context,
        ResolveInfo $info,
        array $value = null,
        array $args = null
    ) {

        $name = $args['input']['name'];
        $number = $args['input']['number'];
        $email = $args['input']['email'];
        $password = $args['input']['password'];
        $gender = $args['input']['gender'];
        $bdate = $args['input']['bdate'];

        $this->_testModel->setName($name);
        $this->_testModel->setNumber($number);
        $this->_testModel->setEmail($email);
        $this->_testModel->setPassword($password);
        $this->_testModel->setGender($gender);
        $this->_testModel->setBdate($bdate); 
        $thanks_message = [];

        try {
            $this->_testRepository->save($this->_testModel);
            $thanks_message['success_message']="Successfully Added";
        } catch (CouldNotSaveException $e) {
            $thanks_message['success_message']="Something went wrong.";
        }
        return $thanks_message;
    }
}



Here in above resolver file we used:- 




Kpyxal\MutationGraphql\Api\TestRepositoryInterface;
Kpyxal\MutationGraphql\Api\Data\TestInterface;

Additionally, the repository and interface file are designed to save fields such as email, name, and number.
Step 6 :- Final step you check output. Run this query



mutation {
    contactusFormSubmit(
        input:{
            name: "KPYXAL"
            number: "+123456798"
            email: "TEST@TEST.COM"
            password: "pass@123"
            gender: "1"
            bdate: "28/08/2222"       
        }
    ){
        success_message
    }
}



To sum up, mutations in GraphQL are essential for altering data within your application. They not only allow for the creation, update, or deletion of objects but also offer flexibility through various elements such as operation names and input objects. While mutations function akin to POST, PUT, and DELETE requests in REST, their integration with GraphQL’s robust query language provides a powerful toolset for managing data efficiently. As we continue to explore GraphQL, ultimately, understanding these components will help, significantly,  in harnessing the full potential of this dynamic query language.
Happy Coding ..! 



Check more blogs like this:




Query in GRAPHQL



Magento 2.4.5 Installation on ubuntu

The post Mutation in GRAPHQL appeared first on Kpyxal Solutions LLP.



Magento2 Query in GRAPHQL
admin — Mon, 20 Feb 2023 05:32:36 +0000

Magento2 Query in GRAPHQL retrieves data from the application server similar to a REST GET call. Additionally, Adobe Commerce and Magento Open Source GraphQL queries enable mobile apps or browsers to display a diverse range of information, including:




A set of products to be displayed. This can include the entire catalog or those that match customer-specified criteria.



A customer token allows a query to access basic information, billing and shipping addresses, wish lists, order history, and other sensitive data. Moreover, GraphQL can also retrieve shopping cart contents for both guest and logged-in customers



Shopping cart contents. GraphQL supports both guest and logged-in customer carts.



Store configuration values, including theme and CMS settings, the currency code, and supported countries.




Implementation Magento2 Query in GRAPHQL 



Built into Magento 2.4, GraphQL support simplifies data retrieval. The following sections will detail the step-by-step implementation process and provide an example of a Magento2 Query in GRAPHQL.



Step 1 :- You Create registration.php file







Step 2 :- create etc/module.xml file







    
        
            
            
            
        
    




Step 3 :- GraphQL queries are declared under etc/schema.graphqls



type Query {
    formdata: [Formdata] @resolver(class:"Kpyxal\\GraphqlQuery\\Model\\Resolver\\ProductsResolver") @doc(description:"The formdata query returns information about a customer")
}
type Formdata @doc(description: "Formdata defines the customer name and other details") {
    name: String @doc(description: "Get Name")
    number: String @doc(description: "Get Number")
    email: String @doc(description: "Get Email")
    password: String @doc(description: "Get Password")
    gender: Int @doc(description: "Get Gender")
    bdate: String @doc(description: "Get Birth Date")
}




In the above file, the file specifies that ‘type Query’ declares the query operations for our module; furthermore, it highlights the structure and functionality that are essential for proper implementation.



 ‘formdata’ represents the query name, while ‘type Formdata’ outlines the query’s structure, including the resolver (@resolver) class and documentation (@doc).



formdata: [Formdata]  :  if we need array of data than need to put identity in array like:-
name of query = [ Identity name ].
Here identity name is Formdata same name which we are use in : type Formdata 



Step 4 :- Create Resolver Class Model/Resolver/ProductsResolver.php



searchCriteriaBuilder = $searchCriteriaBuilder;
        $this->collection = $collection;
    }

    /**
     * @inheritdoc
     */
    public function resolve(
        Field $field,
        $context,
        ResolveInfo $info,
        array $value = null,
        array $args = null
    ) {
        $alldata = $this->getAllData();
        $arraydata= [];
        if (count($alldata) > 0):
            foreach ($alldata as $data):
                 $arraydata[] = array(
                            'name'=>$data->getName(),
                            'number'=>$data->getNumber(),
                            'email'=>$data->getEmail(),
                            'password'=>$data->getPassword(),
                            'gender'=>$data->getGender(),
                            'bdate'=>$data->getBdate()
                        );
            endforeach;
        endif;
        return $arraydata;
    }

    /**
     * @return Collection
     */
    public function getAllData()
    {
        return $this->collection;
    }
}




The resolver file utilizes 



Kpyxal\GraphqlQuery\Model\ResourceModel\Test\Collection 



to gather data. This data is then assigned to variables including name, number, and email.



{
    formdata{
        name
        number
        email
        password
        gender
        bdate
    }
}



In conclusion, Magento2 Query in GRAPHQL offer a powerful way to retrieve data from the application server, similar to a REST GET call. They provide flexibility in accessing a wide range of information; consequently, enabling mobile apps or browsers to render content efficiently, making it an ideal solution for modern, headless commerce applications.



Happy Coding ..! 



Check More Like This 



–Magento 2.4.5 Installation on ubuntu
The post Magento2 Query in GRAPHQL appeared first on Kpyxal Solutions LLP.