WordPress Conceptual System Model

To create a truly comprehensive conceptual model, we must move beyond “posts and users” and look at the underlying architectural philosophy of WordPress.

The WordPress conceptual model is built on Polymorphism (one structure, many forms) and Extensibility (adding data without changing the schema).

1. The Core Domains

The WordPress universe is divided into five distinct “Engines.”

A. The Content Engine (The Polymorphic “Object”)

The central pillar of WordPress is the Object. Conceptually, WordPress does not distinguish between a “Blog Post,” a “Legal Page,” a “Navigation Menu,” or an “Image.” They are all treated as a Content Entity with different “Type” definitions.

• Entities:
  • Content Object (Post): The container for data.
  • Post Type: The definition that determines the behavior of the Object (e.g., post, page, attachment, revision, nav_menu_item).
  • Content Status: The state in the publishing workflow (Draft, Pending, Private, Published, Protected, Trash).
  • Object Version (Revision): A temporal snapshot of a Content Object for auditing and restoration.
• Conceptual Attributes:
  • Identity: Globally Unique Identifier (GUID) and Slug (URL).
  • Temporal: Creation date, Modified date, Scheduled date.
  • Spatial: Hierarchical Parent (allowing objects to live inside other objects).
• Business Rules:
  • An object can be “orphaned” or have a parent.
  • An object must be owned by an Identity (User).

B. The Taxonomy Engine (The Relationship Logic)

This engine handles how objects relate to each other and how they are classified. It is a three-layered abstraction.

• Entities:
  • Term: A linguistic label (e.g., “Technology”).
  • Taxonomy: The context or “Drawer” (e.g., “Category”, “Tag”, “Genre”).
  • Term Context (Term Taxonomy): The bridge that says “The Term ‘Technology’ is being used as a ‘Category’ here.”
• Relationships:
  • Classification: An Object is “assigned” to a Term Context.
• Business Rules:
  • Taxonomies can be Linear (Tags – no hierarchy) or Hierarchical (Categories – parents/children).
  • A Term can exist in multiple Taxonomies (Conceptually, the word “Blue” could be a ‘Color’ taxonomy and a ‘Mood’ taxonomy).

C. The Identity Engine (The Actor Model)

This domain defines who interacts with the system and what they are allowed to do.

• Entities:
  • Identity (User): A unique actor with credentials.
  • Role: A persona (Administrator, Editor, Author, etc.).
  • Capability: An atomic permission (e.g., publish_posts, manage_options).
• Business Rules:
  • Capability Mapping: Users do not have “permissions” directly; they have “Roles,” and Roles contain “Capabilities.”
  • Content Attribution: Every Content Object must be linked to an Identity.
  • Guest Actor: An unauthenticated identity that can only perform “Read” or “Comment” actions.

D. The Metadata Engine (The Property Bag)

WordPress uses an Entity-Attribute-Value (EAV) model. This is the “secret sauce” that allows WordPress to scale from a simple blog to a complex e-commerce site (WooCommerce) without changing the database structure.

• Entities:
  • Object Meta: Extra properties for Content (e.g., “Price” for a product).
  • User Meta: Extra properties for Identities (e.g., “Twitter Handle”).
  • Term Meta: Extra properties for Classifications (e.g., “Category Icon”).
  • Comment Meta: Extra properties for Interactions.
• Conceptual Logic:
  • Shadow Data: Metadata has no meaning without its parent object. It provides the “Attributes” that the core schema lacks.

E. The Configuration Engine (Global State)

• Entities:
  • Site Options: Global variables that dictate how the entire system behaves (Site Title, Timezone, Active Theme, Active Plugins).
  • Transient: A “Temporary Option” that has an expiration date (used for caching conceptual data).

2. Comprehensive Entity-Relationship Concept

3. Advanced Conceptual Rules (The “Deep” Logic)

1. The “Everything is a Post” Rule:
   • When you create a Navigation Menu, you are creating a Post of type nav_menu_item.
   • When you upload a Photo, you are creating a Post of type attachment.
   • Deep Insight: This means that the same logic used to search for blog posts can be used to generate a menu or a gallery.
2. The “Taxonomy Decoupling” Rule:
   • The system separates the name of a category from the logic of the category. This allows developers to change the name “Uncategorized” to “General” without breaking the links to the hundreds of posts assigned to it.
3. The “Stateless vs. Stateful” Rule:
   • Most content is Stateful (it has a status: draft/publish).
   • Metadata is Stateless (it just is).
   • Options are Global (they affect every user and every post).
4. The “Hook” Concept (The Behavioral Model):
   • While not a data entity, the Hook (Action/Filter) is a conceptual bridge. It allows an External Entity (Plugin) to intercept the data flow between any of the engines listed above.

4. Summary Visual Hierarchy

• Global Layer: Options & Transients (The “Rules of the World”)
• Identity Layer: Users -> Roles -> Capabilities (The “Actors”)
• Structure Layer: Taxonomies -> Terms (The “Map”)
• Content Layer: Posts -> Revisions -> Attachments (The “Land”)
• Interaction Layer: Comments (The “Conversation”)
• Extension Layer: Meta (The “Details” for all layers)

This conceptual model explains why WordPress is so resilient: by keeping the core entities generic (Posts, Terms, Users), the specific implementation (Portfolio, E-commerce, Social Network) can be defined entirely within the Metadata and Post Type definitions.