Wordpress is a famous CMS, but it&#39;s far from &quot;complete&quot; out of the box.
Wordpress is born to solve the &quot;blog&quot; problem, so the native CMS provides only blog functionalities.
Over the years, Wordpress started to be used for building websites that are not traditional blogs, and this trend changed the ecosystem of the platform, which saw emerging plugins, each adding specific functionality to the CMS.
Nowadays, the ecosystem is the platform!
<h2>Why do you need Worpress plugins?</h2>
Your website needs good SEO tools? It&#39;s better to use a dedicated SEO plugin ...
Your website is for a business that sells services, and each service has the same structure of information? You need dynamic data plugins...
Your website lets the user contact you with a form? You need a form plugin...
You... get the idea!
The Wordpress CMS capabilities of the early days are pretty much the same as what Wordpress offers today.
The ecosystem is the platform.
The platform is made of plugins.
You need to know them (and do not abuse)!



<h2>Collection of Plugins</h2>
Here is a list of the most used Wordpress plugins (based on my perspective). I update the list regularly. 
You can add your own plugins to the list by following the instructions that you find in the link. 
<a target="_blank" href="https://elastic-cymbal-9af.notion.site/03bdc660ec38433aaf43f792f13fd9b0?v=dd2a7bfbe2f74038882f136af3ca221c&pvs=74">Top Wordpress Plugins</a>

Interactive collection of most famous and used Wordpress plugins. Included SEO, Dynamic Data, Marketing and Page Builder

Top Wordpress plugins grouped by what they do

Imagine you&#39;re building a reusable <code>&lt;Section&gt;</code> component with React. The Section component renders an HTML <code>&lt;div&gt;</code> tag because you hardcoded it. However, in some cases, you might want to use an other tag instead, for example a <code>&lt;section&gt;</code> HTML tag.
This is a typical scenario when you want your HTML to be more semantic and SEO friendly.
The solution is to let the consumer decide which HTML tag should be used to render the component. 
<h2>The &quot;as&quot; prop</h2>
This is nothing new. It&#39;s an industry standard &quot;approach&quot; that allows you to dynamically decide which HTML tag should be used to render the component. A lot of React Components library use it, like Chakra UI and Material UI.
Without the &quot;as&quot; prop, you&#39;d need to create separate components for each use case, and it makes no sense. Don&#39;t do it!
This is how you consume the &quot;as&quot; prop
<pre><code class="hljs language-tsx">import { Section } from &#x27;./section&#x27;;

const App = () =&gt; {
 return (
 &lt;div&gt;
 &lt;Section as=&quot;section&quot;&gt;CTA&lt;/Section&gt;
 &lt;Section as=&quot;article&quot;&gt;My Article&lt;/Section&gt;
 &lt;Section&gt;This use the default HTML tag of the component&lt;/Section&gt;
 &lt;/div&gt;
 );
};
</code></pre>And this is the component definition
<pre><code class="hljs language-tsx">type SectionProps = {
 as?: React.ElementType,
 children: React.ReactNode,
}

export const Section = (props: SectionProps) =&gt; {

 const { as: Tag = &#x27;div&#x27;, children } = props;

 return &lt;Tag&gt;{children}&lt;/Tag&gt;;

}
</code></pre><h2>Typescript Support for the &quot;as&quot; prop</h2>
React helps us with Typescript types. Using the typescript&#39;s <code>React.ElementType</code> type, provided by React, you will obtain autocomplete for your IDE, like this
<img src="/blog/dynamic-html-tag-in-react-components-with-the-as-prop/as-prop-autocomlete-ide.png" alt="VS Code autocomplete suggestion for the &quot;as&quot; prop">
As an alternative to <code>React.ElementType</code> you can use 
<pre><code class="hljs language-tsx">type SectionProps = {
 as?: keyof JSX.IntrinsicElements,
 children: React.ReactNode,
}
</code></pre>or
<pre><code class="hljs language-tsx">type SectionProps = {
 as?: keyof HTMLElementTagNameMap,
 children: React.ReactNode,
}
</code></pre>

Learn how to add the "as" prop to your React Component, to add dynamic HTML tags decided by the consumer Component

Dynamic HTML Tag in React Components with the "as" prop

<h2>Our schema</h2>
<pre><code class="hljs language-sql">create table &quot;post&quot; (
 id SERIAL PRIMARY KEY,
 title VARCHAR(255) NOT NULL,
 content TEXT NOT NULL
);

create table &quot;user&quot; (
 id SERIAL PRIMARY KEY,
 name VARCHAR(255) NOT NULL
)

create table &quot;post_like&quot; (
 id SERIAL PRIMARY KEY,
 post_id INTEGER NOT NULL REFERENCES post(id),
 user_id INTEGER NOT NULL REFERENCES user(id)
)
</code></pre>Now we want to ensure that each user cannot like the same post more than once.
This can be prevented by:
<ul>
<li>using a <code>unique</code> constraint on the pair <code>post_id</code> + <code>user_id</code> columns of the <code>post_like</code> table.</li>
<li>or removing the <code>id</code> column of the <code>post_like</code> table and use a composite primary key on <code>post_id</code> + <code>user_id</code></li>
</ul>
But, assuming we are at a point where duplicates are already there, we need to remove them.
<h2>Check if there are duplicates</h2>
<pre><code class="hljs language-sql">select 
 post_id, 
 user_id,
 count(*)
from post_like
group by post_id, user_id
having count(*) &gt; 2
;
</code></pre><pre><code class="hljs language-md">| post_id | user_id | count |
| ------- | ------- | ----- |
| 3 | 2 | 2 |
</code></pre>This output tells us that user <code>2</code> has liked post <code>3</code> more than one time, specifically 2 times.
<h2>Remove duplicates</h2>
Now that we know that there are duplicates, we can remove them. We split this process in two step:
<ul>
<li>read duplicates</li>
<li>remove duplicates (dry run)</li>
<li>remove duplicates (real run)</li>
</ul>
Read duplicates
<blockquote>
Transaction rollback To test our queries without removing real data, until we are sure the query is correct, we use the transaction <code>rollback</code> feature. By doing this our query will never be committed, is similar to the
&quot;dry run&quot; concept that you can find on other applications (like
rsync).
</blockquote>
<blockquote>
CTE We use <code>CTE</code> because it provides a good DX. With <code>CTE</code>, we can run a query, store the results in a temporary table, and then use the same table for subsequent queries. This mental model is similar to what we usually do in coding by creating a temporary variable. The CTE syntax is 
<pre><code class="hljs language-sql"> with 
 &lt;cte_name&gt; as (
 &lt;query&gt;
 ),
 &lt;cte_name_2&gt; as (
 &lt;query_2&gt; -- here we can refernce &lt;cte_name&gt;
 )
 &lt;final_query&gt; -- here we can refernce &lt;cte_name&gt; and &lt;cte_name_2&gt;
</code></pre></blockquote>
With both transaction and CTE, we can do the following:
<pre><code class="hljs language-sql">begin; -- start transaction

with
duplicates_info as (
 select
 row_number() over (
 partition by post_id, user_id order by user_id
 ) as group_index,
 id,
 post_id,
 user_id
 from post_like
)
select *
from duplicates_info
;

rollback; -- ends transaction discarding every changes to the database 
</code></pre><pre><code class="hljs language-md">| group_index | id | post_id | user_id |
| ----------- | -- | ------- | ------- |
| 1 | 1 | 1 | 1 |
| 1 | 2 | 2 | 2 |
| 1 | 3 | 3 | 2 |
| 2 | 4 | 3 | 2 |
</code></pre>The latest row of results, where <code>group_index</code> is 2, means that this row is the second one in the group with post_id = 3 and user_id = 2.
<blockquote>
What happens here with the syntax?
<code>row_number() over (partition by ...) as group_index</code> is a window function that, first group rows by the columns in the <code>partition by</code> clause, and then assigns a number to each row, based on the index of the row in the group. <code>partition</code> is similar to <code>group by</code>, because it groups the rows by a common column, but if <code>group by</code> return only 1 row for each group, <code>partition</code> let us add new columns to the source table based on groups.
 <code>group_index</code> is a column name alias, regular sql syntax. 
</blockquote>
Filter only duplicates
Now let&#39;s keep only items with <code>group_index &gt; 1</code>, which means that the row is not the first one in the group, or in other words, it is a duplicate.
<pre><code class="hljs language-diff">begin; -- start transaction

with
duplicates_info as (
 select
 row_number() over (
 partition by post_id, user_id order by user_id
 ) as group_index,
 id,
 post_id,
 user_id
 from post_like
)
select *
from duplicates_info
+ where group_index &gt; 1
;

rollback; -- ends transaction discarding every changes to the database 
</code></pre><pre><code class="hljs language-md">| group_index | id | post_id | user_id |
| ----------- | -- | ------- | ------- |
| 2 | 4 | 3 | 2 |
</code></pre>We need to remove only this row, with id <code>4</code>.
Remove duplicates - dry run
Now rewite the final query so that we read from <code>post_like</code> table and not anymore from the cte <code>duplicates_info</code>.
We still use the cte <code>duplicates_info</code> to get the <code>id</code> of the duplicates.
<pre><code class="hljs language-diff">begin; -- start transaction

with
duplicates_info as (
 select
 row_number() over (
 partition by post_id, user_id order by user_id
 ) as group_index,
 id,
 post_id,
 user_id
 from post_like
)
- select *
- from duplicates_info
- where group_index &gt; 1
+ select *
+ from post_like
+ where id in (
+ select id from duplicates_info
+ where group_index &gt; 1
+ )
;

rollback; -- ends transaction discarding every changes to the database 
</code></pre>We will see the records that we want to remove. After we checked that they are correct, we swap <code>select</code> with <code>delete</code>.
<pre><code class="hljs language-diff">begin; -- start transaction

with
duplicates_info as (
 select
 row_number() over (
 partition by post_id, user_id order by user_id
 ) as group_index,
 id,
 post_id,
 user_id
 from post_like
)
- select *
+ delete
from post_like
where id in (
 select id from duplicates_info
 where group_index &gt; 1
)
+ returning * -- will output deleted rows
;

rollback; -- ends transaction discarding every changes to the database 
</code></pre>This last query is what we finally want to execute. But becuase we still have <code>rollback</code> statement, these chhanges are simulated, and not applied to the database.
Remove duplicates - real run
Finally we can remove the duplicates for real.
Here we use <code>commit</code> instead of <code>rollback</code>, so that the changes are applied to the database.
<pre><code class="hljs language-diff">begin; -- start transaction

with
duplicates_info as (
 select
 row_number() over (
 partition by post_id, user_id order by user_id
 ) as group_index,
 id,
 post_id,
 user_id
 from post_like
)
delete
from post_like
where id in (
 select id from duplicates_info
 where group_index &gt; 1
)
returning * -- output deleted rows
;

- -- ends transaction discarding every changes to the database 
- rollback; 

+ -- ends transaction applying changes to the database
+ commit; 
</code></pre><h3>Final Code</h3>
<pre><code class="hljs language-sql">-- start transaction
begin; 

with
duplicates_info as (
 select
 row_number() over (
 partition by post_id, user_id order by user_id
 ) as group_index,
 id,
 post_id,
 user_id
 from post_like
)
delete
from post_like
where id in (
 select id from duplicates_info
 where group_index &gt; 1
)
returning * -- output deleted rows
;

-- ends transaction discarding every changes to the database 
-- rollback; 

-- ends transaction applying changes to the database
commit; 
</code></pre>

Short guide on how to find duplicate data in a Postgres table and remove only duplicates