Chetan Upare

WordPress does not provide a native way to model real relationships between content items such as posts, users, and terms. 
Most solutions rely on post meta or taxonomies, which become difficult to query, scale, and maintain over time.
If you’ve outgrown ACF relationship fields or post meta arrays, Native Content Relationships introduces a structured relationship layer for WordPress that allows you to define meaningful, queryable, and scalable relationships between content — without relying on hacks or editor-specific solutions.
This plugin is designed to be core-friendly, developer-focused, and future-proof, built specifically for developers who have hit performance walls.
<h3>What This Plugin Solves</h3>
• Many-to-many relationships between content 
• Clean querying without meta or taxonomy abuse 
• Long-term maintainability and portability 
• Cleanly handles headless and REST WordPress setups
<h3>Key Features</h3>
• Relationships between posts, users, and terms 
• One-way or bidirectional relationships 
• Indexed database table for fast queries 
• Clean PHP API for managing relationships 
• WP_Query integration 
• REST API support with inline relations 
• Multilingual-ready (WPML / Polylang) 
• WooCommerce optional integration 
• Editor- and theme-agnostic
<h3>Supported Relationship Types</h3>
• Post ↔ Post 
• Post ↔ User 
• Post ↔ Term 
• User ↔ Post 
• Term ↔ Post
<h3>Common Use Cases</h3>
Posts 
• Products → Accessories 
• Courses → Lessons 
• Articles → Related content
Users 
• Favorite posts 
• Bookmarked content 
• Multiple authors or contributors
Terms 
• Featured categories 
• Curated collections 
• Semantic grouping beyond default taxonomies
<h3>Admin Interface</h3>
• Relationship management in post editor 
• User profile relationship management 
• Term editor relationship support 
• AJAX-powered search for posts, users, and terms 
• Modern UI matching WordPress admin style
<h3>Stability & Backward Compatibility</h3>
Schema stable from 1.x onward. Backward compatibility guaranteed.
We lock the core before expanding. Ecosystem and agency confidence depend on it.
<ul>
<li>Database schema stability — The relationship table and <code>NCR_SCHEMA_VERSION</code> are stable in the 1.x line. Any future schema change will be additive (new columns/indexes) or run through a documented migration; no breaking table or column renames without a major version.</li>
<li>Backward compatibility promise — Public PHP APIs (functions, hooks, WP_Query arguments), shortcodes, and REST endpoints will not be removed or changed in breaking ways within the 1.x branch. Deprecations will be announced and supported for at least one minor version.</li>
<li>Versioning policy — 1.x = stable core. Minor/patch releases may add features and fix bugs; they will not break existing integrations. A major version (2.x) would be the only place for intentional breaking changes, with a clear migration path.</li>
<li>Namespacing discipline — One internal prefix: <code>ncr_</code> (functions, hooks, options), <code>NCR_</code> (classes, constants), <code>ncr-</code> (CSS/IDs/handles). No new alternate prefixes; documented and consistent so extensions and ecosystem plugins can rely on a stable surface.</li>
</ul>
<h3>Architected for Performance & Scale</h3>
Native Content Relationships is built for high-volume enterprise and headless WordPress sites. Forget the performance bottleneck of post-meta.
<ul>
<li>Index Optimization: Built on composite covering indexes (<code>type_lookup</code>) and a smart query planner optimized for performance.</li>
<li>Micro-Optimized Validations: SQL-native validations ensure sub-2ms P95 latency even at 1M+ rows.</li>
<li>Object Cache Integration: Full compatibility with object cache through group isolation, targeted relationship cache invalidation, and bulk priming strategies.</li>
<li>Performance Diagnostics: Includes a powerful CLI diagnostic utility to check and fix integrity without UI bloat.</li>
</ul>
Benchmarks confirm stable performance with 1,000,000+ relationship rows under InnoDB. 
<a href="https://github.com/chetanupare/WP-Native-Content-Relationships/blob/main/docs/PERFORMANCE.md" rel="nofollow ugc">View Full Performance Report</a>
<h3>ACF Migration (Escape Meta Technical Debt)</h3>
If you store relationships in Advanced Custom Fields relationship fields or standard Post Meta, you can safely migrate to Native Content Relationships to unlock immediate performance and querying benefits.
A built-in script allows you to selectively migrate ACF related data into the new performant table, allowing you to gradually refactor out technical debt. 
Check out the dedicated one-time migration guide here: <a href="https://github.com/chetanupare/WP-Native-Content-Relationships/blob/main/docs/migration/from-acf.md" rel="nofollow ugc">docs/migration/from-acf.md</a>
<h3>Advanced Developer APIs</h3>
Built to be a complete content relationship modeling engine:
<ul>
<li>Relationship Type Registration API: Programmatic type registration for custom relationships, with schema validation and strict directional logic.</li>
<li>Relationship Constraints: Declare relationship constraints like 1:1, 1:N, or M:N and strictly enforce maximum capacities and duplicates. </li>
<li>Advanced Query Parameters: Inject the <code>content_relation</code> argument directly into your <code>WP_Query</code> with parameters specifically designed for advanced use cases: include multiple relationship types, apply exclusionary rules, combine <code>OR</code>/<code>AND</code> relations, or filter by minimum/maximum thresholds. </li>
<li>Bulk Operations API: Optimized batch operations to bulk attach, bulk detach, and WP-CLI data import designed specifically for use cases when scaling up and executing large workloads.</li>
<li>Lightweight Metadata Add context to relationships natively using relationship metadata (allow order rankings, contexts, descriptions, tracking data, etc.) via a dedicated relationship metadata registry and table.</li>
<li>Graph Utility Layer An ultra-minimal set of APIs and WP-CLI commands that generate graph diagnostics—useful for acquiring relationship counts, calculating the most connected posts, isolating orphaned items, and running background integrity checks.</li>
</ul>
<h3>Headless REST Readiness</h3>
For decoupled and highly dynamic solutions, Native Content Relationships includes powerful headless optimizations:
Append <code>?naticore_relations=1</code> or <code>?_embed=relations</code> into your standard core endpoint fetches (e.g., <code>wp/v2/posts</code>) to embed related data inside your response arrays instantly, minimizing round trips.
<h3>Integrations</h3>
• WooCommerce (product relationships) 
• WPML / Polylang (relationship mirroring) 
• Elementor (dynamic content support) 
• Gutenberg (related content block) 
• Advanced Custom Fields (one-time migration tool)
<h3>Page Builder Integration</h3>
Elementor: 
* Compatible with: Elementor 2.0+ 
* Features: Comprehensive Dynamic Tags suite for relationships 
* Auto-detected: Yes (no configuration needed) 
* Tested up to: Elementor 3.20
Elementor Dynamic Tags: 
* Related Posts: Display related posts with customizable output formats 
* Related Users: Display users with relationships (favorites, bookmarks, etc.) 
* Related Terms: Display taxonomy terms with relationships 
* Flexible Output: IDs, titles, links, avatars, count-only options 
* Direction Support: Both outgoing and incoming relationships 
* Native Controls: Relationship type selector with validation
Gutenberg: 
* Compatible with: WordPress 5.0+ (Core) 
* Features: “Related Content” block with relationship filtering 
* Always available: Yes (core WordPress feature) 
* Tested up to: WordPress 6.5
<h4>Shortcodes</h4>
Use these in posts, pages, or widgets. They use the current post ID when not specified.
Related posts (default: type=related_to, limit=5): 
[naticore_related_posts type=”related_to” limit=”5″ order=”date” layout=”list” title=”Related Content” class=”my-class”]
Related users (default: type=authored_by): 
[naticore_related_users type=”authored_by” limit=”10″ order=”name” layout=”list” title=”Authors”]
Related terms (default: type=categorized_as): 
[naticore_related_terms type=”categorized_as” limit=”5″ order=”name” layout=”grid” title=”Categories”]
Attributes (all shortcodes): 
* type – Relationship type slug (e.g. related_to, parent_of, authored_by, categorized_as) 
* limit – Number of items (1–50), default 5 
* order – Sort: date, title (posts) or name (users/terms) 
* post_id – Post ID; omit to use current post 
* layout – list or grid 
* title – Heading text above the list (optional) 
* class – Extra CSS class(es) for the wrapper 
* show_thumbnail – 1 to show post thumbnail (posts shortcode only), default 0 
* excerpt_length – Number of words for excerpt (0 = hide), default 0
<h4>Widget</h4>
Related Content (NCR) is available under Appearance → Widgets. Add it to any sidebar or widget area.
<ul>
<li>Title – Optional widget title (leave blank to use the shortcode’s default “Related Content” heading)</li>
<li>Relationship type – e.g. Related To, Parent Of, Depends On</li>
<li>Number of items – 1–50</li>
<li>Order by – Date or Title</li>
<li>Post ID (optional) – Leave 0 to use the current post; set a post ID to show relations for a specific post</li>
</ul>
Output matches the shortcode (same markup and styles when the shortcode CSS is enqueued).
<h3>Developer Guide (Advanced)</h3>
This section is intended for developers who want programmatic control.
<h4>Core API</h4>
Add a relationship: 
 wp_add_relation( $from_id, $to_id, $type );
Get related items: 
 wp_get_related( $id, $type );
Check relationship: 
 wp_is_related( $from_id, $to_id, $type );
Remove relationship: 
 wp_remove_relation( $from_id, $to_id, $type );
<h4>WP_Query Integration</h4>
new WP_Query( array( 
‘post_type’ => ‘post’, 
‘content_relation’ => array( 
‘post_id’ => 123, 
‘type’ => ‘related_to’, 
), 
) );
<h4>REST API</h4>
Endpoints available under: 
 /wp-json/naticore/v1/
• Create relationships 
• Fetch related content 
• Delete relationships
Embed relations in core REST responses (headless): 
Add <code>?naticore_relations=1</code> to any core resource request to include a <code>naticore_relations</code> array in the response. Works with: 
• <code>GET /wp-json/wp/v2/posts/<id>?naticore_relations=1</code> 
• <code>GET /wp-json/wp/v2/users/<id>?naticore_relations=1</code> 
• <code>GET /wp-json/wp/v2/categories/<id>?naticore_relations=1</code> (and other taxonomies) 
Each relation item includes <code>to_id</code>, <code>to_type</code>, <code>type</code>, and optional <code>title</code>/<code>display_name</code>/<code>name</code>. Opt-in only so default requests stay fast.
<h4>Hooks & Filters</h4>
Actions: 
• <code>naticore_relation_added</code> 
• <code>naticore_relation_removed</code> 
• <code>naticore_after_duplicate_post</code> – fired after copying relations from one post to another (args: from_post_id, to_post_id, result array)
Filters: 
• <code>naticore_relation_is_allowed</code> 
• <code>naticore_get_related_args</code>
Duplicate post: Use helper <code>naticore_copy_relations( $from_post_id, $to_post_id, $relation_types = null )</code> to copy relationships when duplicating a post. Returns array with keys <code>copied</code>, <code>skipped</code>, <code>errors</code>. Out-of-the-box integration: Yoast Duplicate Post, Post Duplicator (metaphorcreations), Copy & Delete Posts (Inisev).
<h4>Elementor Integration</h4>
This plugin provides comprehensive Elementor Dynamic Tags for displaying relationships in Elementor-powered designs.
Available Dynamic Tags:
<ul>
<li>
Related Posts (ncr-related-posts)
<ul>
<li>Display posts related to the current post</li>
<li>Supports all post-to-post relationship types</li>
<li>Output formats: IDs, titles, links, count</li>
<li>Direction control: outgoing/incoming</li>
</ul>
</li>
<li>
Related Users (ncr-related-users)
<ul>
<li>Display users with relationships to posts</li>
<li>Supports user relationship types (favorites, bookmarks, etc.)</li>
<li>Output formats: IDs, names, emails, avatars, profile links</li>
<li>Direction control: posts-to-users/users-to-posts</li>
</ul>
</li>
<li>
Related Terms (ncr-related-terms)
<ul>
<li>Display taxonomy terms with relationships</li>
<li>Supports term relationship types (categories, tags, etc.)</li>
<li>Output formats: IDs, names, slugs, archive links</li>
<li>Direction control: posts-to-terms/terms-to-posts</li>
</ul>
</li>
</ul>
Usage Examples:
Display related post IDs: 
 <code>[ncr-related-posts relationship_type="related_to" output_format="ids" limit="5"]</code>
Display user avatars: 
 <code>[ncr-related-users relationship_type="favorite_posts" output_format="avatar_images" avatar_size="48"]</code>
Display term links: 
 <code>[ncr-related-terms relationship_type="categorized_as" output_format="term_links" limit="10"]</code>
Get count of related items: 
 <code>[ncr-related-posts relationship_type="related_to" output_format="count"]</code>
Advanced Features: 
– Context-aware: Automatically detects current post, user, or term context 
– Fallback content: Display custom text when no relationships found 
– Pagination support: Limit results for performance 
– Ordering options: Sort by date, title, or random 
– Multi-language: Works with WPML/Polylang translations
Integration Benefits: 
– Native Elementor experience: Tags appear in Elementor’s Dynamic Tags panel 
– No templates forced: Users control output format and styling 
– Performance optimized: Uses cached relationship data 
– Optional dependency: Only loads when Elementor is active
<h4>WP-CLI</h4>
• List relationships 
• Add / remove relationships 
• Integrity checks
<h3>Contributing</h3>
Contributions are welcome. 
GitHub: https://github.com/chetanupare/WP-Native-Content-Relationships
<h3>License</h3>
GPLv2 or later

Native Content Relationships

Add first-class relationships between posts, users, and terms using a fast, structured, and scalable architecture.

Ross Wintle

This plugin provides a library for developers to use to create AJAX-powered drop-down post select boxes.
This is best explained with an example. Say you have a plugin or theme that sets up a custom post type called “Resources”. You want users to be able to manually create, for each post, “Related posts” and “Related resources” using meta boxes with data (the IDs of the related posts/resources) saved to custom fields.
One way to do this is to use a select box. This would be a big long list of ALL the posts or resources on your site. This is not very user friendly, but also, with a large number of posts and resources to list, can be a real performance hog. I’ve even had this approach blow the PHP memory_limit and break the admin of sites.
This plugin improves both the user experience and performance of creating selectable post lists by enhancing them with the functionality of AJAX-powered <a href="https://github.com/select2/select2" rel="nofollow ugc">Select2</a> select boxes.
The plugin:
<ul>
<li>gives a simple way to select posts from a specified post type based on a partial, case-insensitive title search</li>
<li>saves selected post IDs to custom post meta variables</li>
<li>requires minimal coding (but, sadly, does require some coding in your plugin or theme)</li>
</ul>
Select2 is MIT Licensed and Copyright (c) 2012-2015 Kevin Brown, Igor Vaynberg, and Select2 contributors,
<h3>Configuration</h3>
This plugin provides a library for you to use in Themes and Plugins that you create. To use it you will need to add some code to your plugin or theme. Not much, but you will need to add some.
The basic steps are:
<ol>
<li>initialise the post selectors</li>
<li>create a meta box that displays on your custom post type’s edit page</li>
<li>populate the meta box with the post selectors</li>
<li>getting your data out</li>
</ol>
Note: all code here is prefixed with ‘demo‘ – please change this to an appropriate prefix for your own project or put the calls in a wrapper class or namespace of some sort._
<h3>Initialise Post Selectors</h3>
You should initialise the Post Selectors on admin_init – they aren’t required in the front end.
You should call S2PS_Post_Select::create() for each post selector that you want to create.
The parameters to the create method are:
<ul>
<li><code>$field_id</code> – this is the ‘name’ of the field – used to identify it for printing or saving – it must be unique for your post selector</li>
<li><code>$meta_key</code> – the meta_key to fetch/save data to/from</li>
<li><code>$form_field_name</code> – the name attribute of the select form field to be created</li>
<li><code>$form_field_label</code> – the label text for the select form field</li>
<li><code>$post_post_type</code> – the post type of the posts which we want the select box to appear for</li>
<li><code>$item_post_type</code> – the post type of the things to appear in the select list</li>
<li><code>$additional_query_params</code> – any additional query params for generating the list (if you want to filter what appears in the selector); this is an array of parameters that you would pass to <code>WP_Query</code> – you can pass pretty much anything, I think, except post_type. Using things like pagination parameters probably isn’t recommended.</li>
</ul>
The first parameter, <code>$field_id</code>, is needed when adding the code to display the post selector, so remember what they are.
Here’s some code that initialises “Related posts” and “Related resources” (of “resources” custom post type) to be displayed on the edit screen of posts.
<pre><code>add_action('admin_init', 'demo_create_post_selects');
function demo_create_post_selects() {
 S2PS_Post_Select::create( 'related-articles', 'related-articles', 'demo_related_articles', 'Related articles', 'post', 'post');
 S2PS_Post_Select::create( 'related-resources', 'related-resources', 'demo_related_resources', 'Related resources', 'post', 'resources' );
}
</code></pre>
<h3>Create meta boxes</h3>
This just uses a standard WordPress add_meta_box call to add a meta box to the post type that you want to display the selectors in. The callback to print the content of the meta box (<code>demo_print_related_items_meta_box</code>) will use the code in the next section to display the post selectors.
<pre><code>add_action('add_meta_boxes', 'demo_add_related_items_meta_box');
function demo_add_related_items_meta_box() {
 add_meta_box( 'related_items', 'Related Items', 'demo_print_related_items_meta_box', 'post', 'normal',
 'default' );
}
</code></pre>
<h3>Add post selectors to meta boxes</h3>
This is the callback that is called to display the contents of the meta box. Here we need out <code>$field_id</code>‘s from the first section of code.
<pre><code>function demo_print_related_items_meta_box( $post ) {
 S2PS_Post_Select::display( 'related-articles' );
 S2PS_Post_Select::display( 'related-resources' );
}
</code></pre>
<h3>Getting data out</h3>
Data is stored as regular post meta, so you can retrieve it with <code>get_post_meta()</code> calls (or other functions that get post meta for you).
One important thing to note is that if multiple posts are selected in a given field then these are stored as multiple post meta entries with the same key. So, when you call <code>get_post_meta()</code>, ensure that the <code>$single</code> parameter is set to <code>false</code> (it is by default).

Select 2 Post Selector

I was in urgent need of understanding Select2 for my own projects.  The really clear code in this plugin made it a breeze to clone what I needed.
Thanks!!!!



Great Job, you rock!

Provides developers with a simple means of creating AJAX-powered Select 2 post select meta boxes

Native Content Relationships vs Select 2 Post Selector