The 2023.10 version of the Aimeos e-commerce framework for Laravel and TYPO3 is available now! Especially developers will love the 2023 version because it contains a lot of simplifications and fully supports scaleable cloud setups like Kubernetes natively. The most important updates in 2023 are:

• Laravel 10 distributions
• TYPO3 12 support
• Kubernetes/Serverless support
• Create managers easily
• Merged order and order base
• Stored basket panel
• DB-based translations for type names
• VueJS and GraphQL in backend

Laravel 10 distributions

Since the Laravel 10 release in February 2023, Aimeos fully supports the latest Laravel version and since 2023.04, the Aimeos headless and full stack distribution are based on Laravel 10. You can bootstrap your own Aimeos application in less than five minutes using those distributions and get a fully working Laravel 10 application. This also includes pre-configured authentication setup for both, the full stack and the headless distribution.

TYPO3 12 support

Also, Aimeos 2023.x fully supports TYPO3 12.4 since it’s release in April. Many changes has happened in v12 compared to v11, especially a lot of deprecated code has been removed. This made it very hard to make Aimeos 2023.x available for TYPO3 v11 too so we’ve decided to support v12 only in that release. Therefore, if you need a feature from Aimeos 2023.x or want to upgrade after two years of free support, you must upgrade to the latest TYPO3 v12 too.

Kubernetes/Serverless support

We are proud to announce that Aimeos 2023+ is the first cloud-native e-commerce solution for Laravel. Everything including file imports can be distributed across any cloud environment like Kubernetes, AWS, Google Cloud, Azure or so called serverless environments now. Aimeos for Laravel is cloud-ready since the beginning and images/CSS/JS files can be stored in S3 or similar cloud storage services but files were read only from a local file system. This this year, you can store files for importing products, categories, users, etc. from any remote server regardless if they are in CSV or XML format.

We also moved our complete server infrastructure from traditional hosting to a private Kubernetes cloud beginning this year including the web sites, demo setups and private package repository.

Create managers easily

Extending existing managers is extremely simply but writing new managers for own data domains or extending existing data domains required a lot of boilerplate code in the past. Since 2023.10, creating new managers is as easy as extending managers now.

First of all, create a setup task for the database migration as before:

namespace Aimeos\Upscheme\Task;

class Test extends Base
{
    public function up()
    {
        $this->info( 'Creating test schema', 'v' );

        $this->db( 'db-test' )->table( $name, function( $table ) {
            $table->engine = 'InnoDB';

             $table->id()->primary( 'pk_mstes_id' );
             $table->string( 'siteid' );
             $table->string( 'label' )->default( '' );
             $table->int( 'position' )->default( 0 );
             $table->smallint( 'status' )->default( 1 );
             $table->meta();
         } );
    }
}

Then, create the manager for the new domain named “test”:

namespace Aimeos\MShop\Test\Manager;

class Standard
    extends \Aimeos\MShop\Common\Manager\Base
    implements \Aimeos\MShop\Common\Manager\Iface
{
    public function getSaveAttributes() : array
    {
        return $this->createAttributes( [
            'label' => [
            ],
            'status' => [
                'type' => 'int',
            ],
            'position' => [
                'type' => 'int',
                'label' => 'Position for sorting'
            ],
        ] );
    }
}

That’s all! You can work with your new manager like with any other manager from the Aimeos core:

$manager = \Aimeos\MShop::create( $this->context(), 'test' )

$item = $manager->create()
    ->set( 'label', 'test label' )
    ->set( 'position', 2 )
    ->set( 'status', 1 );

$item = $manager->save( $item );

$label = $item->label;
// or using get() with default value
$label = $item->get( 'label', 'default value' );

For more information, there’s an article about creating new managers in the Aimeos documentation.

Merged order and order base

The biggest architectural change since the beginning is simplifying the order data domain by merging the order and order base tables/managers/items. The initial idea behind was that we can have several invoice/refund entries for each stored order base item (=basket) but that turned out to not work well over the years and complicated handling orders a lot. Thus, the data is all stored in the order record now.

That leads to some consequences, especially for the JSON:API as this change isn’t backward compatible! An application using the JSON:API doesn’t need to use the order endpoint any more to create an order item because the basket endpoint did that already. Furthermore, the property names in the basket changed and “.base” has to be removed.

The JSON:API has been backward compatible for six years (2017-2022) and we want to keep v2 stable for the next 5-10 years now.

Stored basket panel

Customer baskets are stored in the database during some time and now, the admin backend contains a new “Sales > Baskets” Panel in the admin backend. Administrators and editors can check saved and abandoned baskets of the customers and it’s also possible to send emails to 3rd party applications for reminding customers about their abandoned carts.

DB-based translations for type names

Before, translations for attribute types were only possible by translating them statically the Gettext translation files or in the Aimeos configuration. Thus, only developers were able to update these translations and it was difficult to update translations if they have been delivered by ERP systems.

Now, type translations are saved in the database along with the types and can be edited in the admin backend and updated easily by ERP systems. This is available for all types, not only attribute types.

VueJS and GraphQL in backend

Several panels have been rewritten in the admin backend to use VueJS components now. This lead to better code quality and is another step forward to remove all jQuery-related code in the next versions. Also, VueJS components for which no VueJS 3 version is available has been replaced by better supported ones, namely the combo box select components which have been replaced by Vue Multiselect now. Finally, this will make the upgrade to VueJS 3 possible in the next versions.

Furthermore, requests to the JSON admin API has been replaced by requests to the new GraphQL API where possible. We will continue to extend the GraphQL API and replace existing JSON admin API requests until we completely phased out the JSON admin API. In 2024.x, the JSON admin API will be also marked as deprecated. The frontend JSON:API will never be replaced and will be the only way for frontends to interact with Aimeos servers as GraphQL is not suited well for read-heavy applications like e-commerce apps.

The new Aimeos feature release contains some long-awaited new stuff for developers and customers alike. What you get by using the 2020.07 release among various minor improvements and bugfixes is:

• PDF invoice in order confirmation e-mail
• Supplier CSV import
• Improved admin backend for mobile phones
• Better full text search and URL segments
• Official TYPO3 10 support
• Simplified manager and criteria filter methods

PDF invoice in confirmation e-mail

One of the most often requested features is now part of the Aimeos core: A nice looking template which can be easily adapted to the clients requirements and corporate design. The full source code for the invoice PDFs was contributed by the Aimeos GmbH.

The PDF document is generated from a HTML template and automatically attached to the e-mails sent to customers when the order has been paid. You can change the content and the layout of the PDF by adapting the template only, including header and footer sections repeated on each page.

Internally, the TCPDF library is used for creating the PDF from the HTML template, which also supports splitting long content to several pages automatically. In composer based setups, TCPDF is automatically added and installed as dependency. For TYPO3 integrators who still download packages from TER, there’s a new dependency the pdfviewhelpers extension due to the size of the TCPDF libary.

Supplier CSV import

Up to version 2020.07, you have been able to import several entities via configurable CSV files:

• attributes
• categories
• coupon codes
• products
• stock levels

Now, you can also import supplier data including addresses, images, texts and references to other domains like products. Also, you can add supplier references in the product CSV import too.

This part of the new release was a big contribution by Alexey, an Aimeos developer and freelancer who offers his expertise for custom projects.

Improved admin backend for mobile phones

Thanks to Robert, who did an amazing job improving the backend styles, the Aimeos admin interface is much better usable by mobile phone users regardless of their display size. Even with an old iPhones which only have 320px width, managing the items is fully possible now.

Header texts which are too long fade out, the size of the buttons has been adapted to the smallest supported viewport size and all tables gets a scollbar if their columns are bigger than the screen.

Additionally, the left navigation menu got some love and displays the names of the navigation items when clicking on the bottom arrow button. Thus, mobile phone users can see what their meaning is if they can’t remember.

Better full text search and URL segments

The results of the full text search offered by MySQL, PostgreSQL and SQL Server has been refined to return more relevant results. Especially for phrases with several words, stop words and special characters, it yields much better results now.

Optimized URL segments can be added as text to products and categories, but generating URL segments from labels led to a loss of characters if special characters not covered by the ASCII character set was used. Thanks to the “voku/portable-ascii” library, these characters are now transliterated to the best matching ASCII character or to several characters like for “ä -> ae”.

Official TYPO3 10 support

Three month after TYPO3 10 LTS has been released, the Aimeos TYPO3 extension officially supports the new TYPO3 major release. It took some time until the static_info_tables extension was available for TYPO3 10, which Aimeos depends on.

The Aimeos 20.7.x extension supports TYPO3 v9 and v10 only because it removes all methods deprecated by v9 and dropped in v10 to clean up the code base. Furthermore, it uses the new APIs if applicable and offers it’s own panel for all Aimeos plugin elements with icons and descriptions to support new users.

Simplified manager and criteria filter methods

Working with Aimeos should be fun and even you can do the most complex things in e-commerce using Aimeos, the code you have to write should be as small as possible. Therefore, the manager methods have been shorted to:

Also, building filter criteria for the search() method is now much easier. Instead of:

$search = $manager->createSearch( true )->slice( 0, 100 );
$search->setConditions( $search->combine( '&&', [
    $search->compare( '==', 'product.type', 'default' ),
    $search->compare( '==', 'product.dataset', 'shirt' ),
    $search->compare( '>', 'product.datestart', '2020-01-01' ),
    $search->getConditions()
] ) );
$search->setSortations( [
    $search->sort( '-', 'product.label' ),
    $search->sort( '+', 'product.id' )
] );

You can now write using the new 2020.07 release:

$f = $manager->filter( true )->slice( 0, 100 )
    ->add( ['product.type' => 'default', 'product.dataset' => 'shirt'] )
    ->add( 'product.datestart', '>', '2020-01-01' )
    ->sort( ['-product.label', 'product.id'] );

This will cover 95% of all use cases. A more complex example including mixed AND and OR operators:

$f->add( $f->and( [
    $f->or( [
        $f->is( 'product.datestart', '<', '2000-01-01' ),
        $f->is( 'product.datestart', '==', null ), ]
    ),
    $f->or( [
        $f->is( 'product.dateend', '>', '2000-01-01' ),
        $f->is( 'product.dateend', '==', null )
    ] ),
] );

You can use the NOT operator for negating all conditions:

$f->add( $f->not( $f->and( [
    $f->is( 'product.type', '==', 'default' ),
    $f->is( 'product.status', '==', 0 ),
] ) ) );

Creating search functions to pass parameters as part of the search key are also much easier to use now:

$f->add( $f->make( 'product:has', ['attribute', 'default', 123] ), '!=', null );

Finally, you can parse a complete condition block like before:

$f->parse( ['||' => [
    [
        '<' => ['product.datestart' => '2000-01-01'],
        '==' => ['product.datestart' => null]
    ], [
        '>' => ['product.dateend' => '2000-01-01'],
        '==' => ['product.dateend' => null]
    ]
] ] );

The old manager and criteria API is still available so all extensions developed from 2020.x will continue to work without problems, but the old APIs are deprecated and will be removed in the future.

More about Aimeos

• Web site: https://aimeos.org
• Github: https://github.com/aimeos
• TYPO3 TER: https://extensions.typo3.org/extension/aimeos/

• Facebook: https://facebook.com/Aimeos
• Twitter: https://twitter.com/Aimeos
• YouTube: https://youtube.com/c/aimeos

The new beta version contains a lot of improvements and focuses on:

• Even more performance
• Developer experience
• Code cleanup

Performance improvements

Aimeos is already known as ultra fast e-commerce solution for Laravel, Symfony, SlimPHP, TYPO3 and Flow/NeosCMS even for complex requirements. This release pushes the limits teared down by Aimeos #gigacommerce further with render times of 20ms and below if content caching is enabled. Without caching, response times are exceptional too compared to other shop systems and in the 2019.01 release, we reduced that time further.

First, we denormalized tables that use types, so the type code is now stored directly instead of the type ID. This saves several database queries per request. Additionally, it’s possible to retrieve related data for e.g. products filtered by type:

$manager->searchItems( $filter, ['text', 'price', 'product' => ['suggestion'] );

This fetches related products of type “suggestion” only instead of all related products. Especially for shops with many relations, this can be a huge performance improvement if components can’t be cached.

PHP 7.3 promises another huge performance improvement and we are testing that version every time. Unfortunately, there’s a bug in PHP 7.3 with prevents production usage yet. It seems that the PHP developers over-optimized opcode caching so PHP 7.3 produces wrong results: https://bugs.php.net/bug.php?id=77310

Simplifications for developers

One of the major goals for this Aimeos release was to simplify interfaces so the first steps for new developers are easier. As a result, creating managers, controllers and clients requires only:

$manager = \Aimeos\MShop::create( $context, 'product' );
$cntl = \Aimeos\Controller\Frontend::create( $context, 'catalog' );
$client = \Aimeos\Client\Html::create( $context, 'catalog/lists' );

Items with relations are fetched recursively now and a decorator limits the recursion depth to two levels. The allowed depth is configurable like everything else in Aimeos. This allows you to get all releated data you need at one without fetching and merging data from several calls to searchItems():

$products = $manager->searchItems( $filter, ['product', 'price', 'text] );

For bundle and selection products, the items in the result list contains the bundled and variant articles including prices, texts and related products.

Also, all newly created items have the status “enabled” by default and must be explicitly disabled if required. This saves many calls to “setStatus()” especially when implementing a new importer. The frontend controllers allow multiple category IDs for filtering so it’s possible to search for
products in multiple categories with one method call.

Code cleanups

Finally, a lot of old code has been removed due to the switch to document oriented managment of items. Especially in the index managers and the filter criteria implementation was some code left after the changes required to use ElasticSearch natively.

The 2019.x releases are the last ones that will support PHP 5 as 5.6 isn’t maintained any more since this year. You should use PHP 7 nevertheless to get the best performance.

For a full list of backward incompatible changes, please have a look at the Wiki article. BC breaking changes in 2019.01 are listed up to 2018-12-31:

https://aimeos.org/docs/Developers/Changelog/2019