We are going to create a single component that supports text, textarea, select, radio, and checkbox. It will absorb all implementation differences for different inputs and will allow us using a unified component in our Formik forms.

When I start on a new project, I always try to abstract specific libraries away by defining my own components. This brings some benefits

* Simplify the code by moving the complex/common part into my custom component.
* Have the ease of changing the underlying dependency without going through a crazy refactoring, but rather only updating my custom component

This time we are going to create a component that seamlessly works with any input type. Then we’re going to integrate it with react-bootstrap without touching any of our forms, but just updating our custom input component.

Let’s see what we’re building first before going into implementation details. This is how our form will look like

![[form.png]]

And here is how we are going to define our form. It’s simple, clean, easy-to-read, right?

```
<form onSubmit={props.handleSubmit}>
  <FormItem
    type="text"
    label="Full Name"
    name="fullName"
  />
  <FormItem
    type="textarea"
    label="Comment"
    name="comment"
  />
  <FormItem
    type="select"
    label="Default Currency"
    name="defaultCurrency"
    options={[
      {value: 'USD', label: 'American Dollar'},
      {value: 'EUR', label: 'Euro'}
    ]}
  />
  <FormItem
    type="radio"
    label="Gender"
    name="gender"
    options={[
      {value: 'male', label:'Male'},
      {value: 'female', label:'Female'},
      {value: 'other', label:'Other'}
    ]}
  />
  <FormItem
    type="checkbox"
    label="Hobbies"
    name="hobbies"
    options={[
      {value: 'baking', label:'Baking'},
      {value: 'dance', label:'Dance'}
    ]}
  />
  <button type="submit">Submit</button>
</form>
```

Ok, now let’s start implementing it.

## Component structure

To make it easier to understand, you can see the structure of the components below. In the following sections, we are going to implement FormItem, FormInput, TextInput, TextAreaInput, SelectInput, and CheckInput.

![[components.png]]

## Creating the container component

```
import {connect} from 'formik';

const FormItem = connect(props => {
  const { label, ...inputProps } = props;
  const { errors, touched } = props.formik;
  return (
    <div>
      {label && <label>{label}</label>}

      <FormInput {...inputProps} />

      {errors[inputProps.name] && touched[inputProps.name] && <p>{errors[inputProps.name]}</p>}
    </div>
  );
});
```

This will contain whatever a form field requires: a label, an input field, and validation errors. Line 8 renders the label if user provided the label prop. Line 10 renders the input component and line 12 renders the validation errors if there is any.

You might be asking where `props.formik` came from. It is added in the props by [connect](https://jaredpalmer.com/formik/docs/api/connect) method we use in line 3. Now our component will have the full formik context.

You can also use Formik’s [Field component](https://jaredpalmer.com/formik/docs/api/field) which is aware of the Formik context without you doing anything. You just need to adjust this FormItem component to make it work with Field component.

## Deciding which input to render

```
const FormInput = props => {
    switch (props.type) {
        case 'radio':
        case 'checkbox':
            return CheckInput(props);
        case 'select':
            return SelectInput(props);
        case 'textarea':
            return TextAreaInput(props);
        default:
            return TextInput(props);
    }
}
```

This one is straight-forward. It just renders the correct input component based on the type prop and passes all props down to that component. We are going to handle radio and checkbox in the same component, namely CheckInput, since they’re quite similar.

## Implementing input components

Every prop you pass to the FormItem will eventually be passed into the actual input element except the ones we defined for our specific use

* `label` is used in FormItem to render the label, so it’s not actually a prop for the input field

* `options` is used to pass the list of options in select, radio and checkbox elements. It will be an array of options like
```
[
  {value: 'val1', label: 'Option 1'},
  {value: 'val2', label: 'Option 2'}
]
```

In addition to the props passed by the user, we should also pass additional props to make it work with Formik such as `value`, `onClick`, `onBlur` etc. We’re going to handle the extraction of the input props in `extractInputProps` method. Let’s leave it’s implementation to the next section.

### TextInput and TextAreaInput

Here how we define our text and textarea inputs. Nothing fancy, just pass the props and render the input element.

```
const TextInput = props => <input {...extractInputProps(props)} />

const TextAreaInput = props => <textarea {...extractInputProps(props)} />
```

### SelectInput

Next, let’s define our select input. It’s similar to the previous ones, but we also need to render a list of options which were passed in the `options` prop in FormItem.

```
const SelectInput = props => (
  <select {...extractInputProps(props)}>
    <option value="">Select a value</option>
    {props.options.map(o =>
      <option key={o.value} value={o.value}>{o.label || o.value}</option>)}
  </select>
);
```

### CheckInput for radio and checkbox

Now combining above two, it’s not too hard to understand radio and checkbox. Radio/Checkbox behaves different than other input elements, which we will handle in `extractInputProps` method.

```
const CheckInput = props => (
  <Fragment>
    {props.options.map(option => (
      <label key={option.value}>
        <input {...extractInputProps(props, option)} />
        {option.label || option.value}
      </label>
    ))}
  </Fragment>
);
```

## Defining extractInputProps method

This method will accept `props` and `option` as parameters. `option` will be passed only by select/radio/checkbox while rendering each option coming from `options` prop.

```
function extractInputProps({formik, options,...otherProps}, option) {
  const props = {
    value: formik.values[otherProps.name],
    onChange: formik.handleChange,
    onBlur: formik.handleBlur,
    ...otherProps
  }

  if (props.type === 'radio') {
    // set additinoal props for radio
  } else if (props.type === 'checkbox') {
    // set additinoal props for checkbox
  }

  return props;
}
```

As you can see from line 6, all the props you passed in FormItem finally reached the actual input elements. But, `props` has more than input element needs. That’s why we use object destructuring on line 1 and remove `formik` and `options` from the props we pass to input element.

Now it’s time to use `formik` prop which we get with Formik’s `connect` method we used in FormItem component. `value`, `onChange`, and `onBlur` attributes are set to values/handlers provided by formik.

Almost done. The only thing left is the special handling of radio and checkbox. Let’s fill those parts in.

### Handing additional props for radio

Each radio button has it’s own `value`. Since they share the same input name, form value is set to the value of the one user clicks. Browser uses `checked` attribute to decide whether it should be rendered as checked/unchecked. So, we set `checked` as true if the value of the radio button we’re rendering is equal to the value set in the form.

```
if (props.type === 'radio') {
  props.value = option.value;
  props.checked = option.value === formik.values[props.name];
}
```

### Handing additional props for checkbox

The default behavior for checkbox is usually not what web applications expect. If you have a group of checkboxes, and some of them are selected, your form values will be something like `{option1: true, option2: false, option3: true}`. But, most applications expect `['option1', 'option2']` as the value in their API. To achieve  this, we’ll override `onChange` method like below. Also `checked` attribute will rely on form value including the value of the checkbox being rendered.

```
else if (props.type === 'checkbox') {
  props.value = option.value;
  props.checked = formik.values[props.name].includes(option.value);
  props.onChange = e => {
    const val = formik.values[props.name];
    e.target.checked
      ? val.push(e.target.value)
      : val.slice(val.indexOf(e.target.value));
    formik.setFieldValue(val);
  }
}
```

## Putting it all together

Here is the full working example

<div class="embed-container">
  <iframe width="100%" height="400" src="//jsfiddle.net/merictaze/vcaukthm/embedded/js,result/" allowfullscreen="allowfullscreen" frameborder="0"></iframe>
</div>

You can easily change the input components and make it work with react-bootstrap as below:

<div class="embed-container">
  <iframe width="100%" height="400" src="//jsfiddle.net/merictaze/2jvcb87r/embedded/js,result/" allowfullscreen="allowfullscreen" frameborder="0"></iframe>
</div>


We are going to create a single component that supports text, textarea, select, radio, and checkbox. It will absorb all implementation differences for different inputs and will allow us using a unified component in our Formik forms.

Creating a unified Formik input field to support all input types seamlessly

In this post, we are going to setup an environment with API Gateway, Lambda and DynamoDB using serverless framework which can be deployed to AWS directly or run fully local.

Going Serverless Offline

Multitasking is the source of all evil. Until recently, I also liked having multiple screens and multi-tasking like many others. It was great to code on one screen while reading the slack messages and emails on the other screen. But, it was so easy to get distracted by continuous incoming notifications while trying to read, write or code something. Often, I was feeling tired in the middle of the day because continuous context switching was draining my energy and destroying my focus on the task I was working on. 

5 Tips To Stop Multitasking and Double Your Productivity

Although what react is doing looks quite complex, underlying logic is very simple. And the easiest way to understand is just running some simple examples. We’ll dive into how react renders components and updates the actual DOM.

How React Rendering Works - A Step by Step Guide

Maybe you’re just getting started with distributed systems and system design, or you just need a quick recap for your upcoming interview. In either case, in this post, you’ll find the most common concepts of system design and the most important aspects of them. Let’s get started.

Recap of System Design Interview Concepts

You solved 60 LeetCode hard and 300 LeetCode medium questions, you were a rockstar in your coding round and provided the most efficient solution in the world, but you couldn’t get the offer. Sounds familiar? Either case, keep reading, you might find some useful tips.

How to Succeed in Your Coding Interview

Attacks like CSRF or XSS are still not clear to many of us. It is not because they are super hard to understand, but it requires some basic understanding of concepts like SOP, CORS, CSP, HTTPS. Let's start with what's Same-origin Policy

Web security unknowns: Same-origin Policy

DynamoDB is Amazon’s NoSQL database which offers single-digit milliseconds latency. It is great for variety of use cases, but when you need to run complex search queries on your dataset, you quickly realise it is not designed for it.

Indexing DynamoDB Items to ElasticSearch using AWS Lambda

While making a simple request to https://google.com to see that simple search page, there are a lot of things going on behind the scenes to keep you secure. Understanding this flow will give you a lot of confidence in various topics like Digital Certificates and Signatures, Symmetric/Asymmetric key encryptions, Certificate Authorities and how they all work together to help you have secure communication.

What happens when you hit google.com using HTTPS

System design questions can be asked for any level with different expectations from the candidate, but to get a Senior offer, you have to rock this round. Practice makes perfect - like for anything else, it applies for system design interview too. So, keep practicing without taking shortcuts, practice as if it’s the real interview and always follow the same steps to make it perfect.