A New Data Access Engine in JCB

[Llewellynvdm]

Recently (two years ago) we introduced a new data access engine in Joomla Component Builder (JCB) that makes working with database data much simpler and more flexible.

This engine allows you to retrieve and store data without worrying about how it is stored internally.

Normally when working with Joomla models or database queries you must remember details such as:

• Whether the data is stored as JSON
• Whether it is Base64 encoded
• Whether fields require special decoding
• Whether the structure needs additional processing

With this engine, you don't need to think about any of that.

The system uses the JCB-generated table metadata to determine:

• the field datatype
• how the data is stored
• how it should be decoded
• how it should be validated when saving

It then automatically prepares the data so that what you receive is ready to use in PHP.

---

Why This Exists

The Joomla model layer is powerful and still plays an important role in JCB. It provides:

• structured MVC behavior
• permission integration
• Joomla-standard workflows

However, sometimes you need more freedom.

This new engine allows you to:

• retrieve data anywhere in your code
• bypass unnecessary model overhead
• work with data quickly and safely
• control permissions yourself instead of relying on the model

So instead of Joomla enforcing permission checks through the model layer, you decide when permissions apply.

For example:

if ($user->authorise('core.edit', 'com_example'))
{
    // fetch data
}

This puts full control back into the developer's hands.

---

Automatic Data Handling

The engine automatically handles:

• JSON decoding
• Base64 decoding
• datatype validation
• correct value formatting when saving

If you attempt to save an incorrect datatype (for example a string where an integer is required), the engine will throw an error immediately.

This helps prevent corrupt data from ever reaching the database.

---

Automatic Insert or Update

The engine also provides a simple set() workflow.

When saving data:

• If the record exists → it updates
• If the record does not exist → it creates a new record

You don't need to manually determine whether to run an INSERT or UPDATE.

---

Cross-Table Flexibility

For more advanced cases, the engine can also operate across multiple tables.

This is the same mechanism used in the demo component example where:

• Subform data is stored in a separate relational table
• Instead of being stored as a JSON blob

This approach makes it far easier to:

• search
• filter
• join tables
• scale large datasets

---

Architecture

The engine uses a factory-based container to provide access to services.

This means:

• objects are reused instead of repeatedly instantiated
• dependency injection remains clean
• the system remains easy to extend

If you prefer, you can even:

• create your own factory
• implement your own classes
• extend the interfaces provided

This keeps the system both stable and customizable.

---

Automatic Code Import in JCB

When you use these examples in your project:

JCB will automatically detect the Power classes being used and import all required code into your project.

Once imported, you can edit or extend them inside the JCB Powers area.

---

Example: Get a Single Item

This example retrieves a single record from a table.

// check the class details here:
// https://git.vdm.dev/joomla/super-powers/src/branch/master/src/9206082e-a3f7-472e-98b2-de90d06cbdcd

$item = Super___9d76b8dc_3883_4755_b11c_131d19ca8a53___Power::('Item')
	->table('#__other_component_table_name')
	->get($id, 'id'); // in other component

What happens here:

1. The Item service is requested from the container.
2. The database table is defined.
3. The get() method retrieves the record where id = $id.

The returned value is already:

• decoded
• validated
• properly structured

---

Example: Get Multiple Items

You can also retrieve multiple items in a single call.

// check the class details here:
// https://git.vdm.dev/joomla/super-powers/src/branch/master/src/21bca8a4-5b28-41c4-843e-8097f0ba7cca

$items = Super___9d76b8dc_3883_4755_b11c_131d19ca8a53___Power::('Items')
	->table('table_name')
	->get([$id], 'id'); // in current component

This retrieves a collection of records matching the provided IDs.

Again, the data returned is already normalized according to the JCB table definitions.

---

When Should You Use This?

This engine is ideal when you want:

• fast and flexible data access
• minimal boilerplate code
• automatic datatype handling
• complete control over permissions
• simple insert/update behavior

For standard Joomla workflows the model layer still remains excellent, but when you need something lighter and more direct, this engine provides a powerful alternative.