With 2025.04, the first stable release of the Aimeos e-commerce framework for 2025 is available now. It’s a new major release with some breaking changes, rewritten code and includes:

• Full translations of frontend and backend in over 30 languages
• Removed jQuery completely
• Feature complete GraphQL API
• Merged all types into single table
• Moved stored baskets to own domain

Translations in over 30 languages

The Aimeos 2025.04 release takes global accessibility to the next level with translations now available in over 30 languages, ensuring users across the world can seamlessly manage their e-commerce platforms as well as buying products or services.

This includes widely spoken languages such as Chinese, French, German, Spanish, Russian, and Arabic, as well as regionally significant ones like Hungarian, Portuguese (Brazilian and European), Romanian, Turkish, Bulgarian, Dutch, Italian, Slovak, Slovenian, Polish, Ukrainian, Estonian, Finnish, Japanese, Greek, and Indonesian. Additionally, support has been extended to Nordic and Baltic languages including Danish, Swedish, Norwegian Bokmål, Latvian, and Lithuanian, along with Czech and Korean, making Aimeos one of the most internationally inclusive e-commerce solutions to date.

No more jQuery code in the backend

Now, jQuery has been completely removed from the code base, marking a significant milestone in modernizing the platform. On the frontend, this transition began earlier with the adoption of the lightweight and efficient cash-dom library, providing a seamless jQuery-like API without the overhead.

Now, the backend has also been fully refactored to use VueJS 3 and vanilla JavaScript, ensuring faster performance, better maintainability, and full compatibility with modern development practices. Even complex UI elements like tree components have been reimplemented without jQuery, offering a cleaner and more responsive admin experience.

GraphQL API – feature complete

With the new release, the GraphQL admin API is now fully feature complete, offering a modern, efficient, and consistent interface for managing all backend data. The latest update adds support for searching category and site trees, further enhancing flexibility and usability for developers.

As a result, the legacy JSON admin API has been removed by default to streamline the platform, but for those who need additional time to transition, the corresponding package can still be installed in addition. This marks a major step forward in making Aimeos more scalable, future-proof, and aligned with industry standards.

Single domain for types

All type tables across data domains have been unified into a single table under the new “type” domain, significantly reducing the amount of code and enabling centralized management of type entries. This structural simplification enhances maintainability and consistency across the system.

As part of this change, the former domain property of type items has been replaced by the actual data domain to which the types belong. To maintain separation where necessary — such as distinguishing between different product list types in product detail sub-panels — additional configuration is now required, offering both flexibility and clearer context-specific behavior.

Moved baskets to own data domain

Stored baskets have been moved from the order domain to a dedicated “basket” domain, bringing significant improvements in both performance and scalability. By decoupling baskets from orders, they can now be stored in a separate database instance, reducing resource contention and enabling more efficient scaling — especially in high-traffic environments. This architectural change ensures smoother handling of active user sessions without impacting order processing, making the system more robust and responsive.

The 2024.10 release for Laravel and TYPO3 with long term support offers some exciting new features and a lot of internal improvements to make live of developers easier than ever before. The highlights of this release are:

• AI-based image generation and background removal
• Extended JSON:API and GraphQL API
• Laravel Octane support
• TYPO3 v13 support
• Simplified managers
• Improved frontend and backend

AI-based image generation and background removal

This release introduces an AI-based image generation feature to create images for categories and CMS articles automatically based on the prompt provided by the editor. This can generate appealing visuals for e.g. cover images quickly without the need of a designer when used correctly. The feature is based on the OpenAI Dall-e 3 API and requires a paid OpenAI account.

Also, Aimeos now includes an automatic background removal feature for newly uploaded (product) images. Before, removing backgrounds was a labor intensive task for designers using expensive Adobe suites but now, it’s done in a matter of seconds and works with humans and products in the front. It uses the RemoveBG API and also requires a paid account for high resolution images.

Extended JSON:API and GraphQL API

After the last release has improved the API documentation, the current version extended the JSON REST and GraphQL APIs.

The JSON:API includes the possibility to fetch type items for attributes, products, services and stocks on request. You only need to add attribute.type, product.type, service.type or stock.type to the “include” parameter of the relevant JSON REST URLs, e.g. &include=attribute.type for attribute endpoint requests. This will return the type item(s) for the attributes in the included section of the response and contains e.g. the translation of types for each language.

The GraphQL API has been extended be able to return and update all order related information. Now it’s possible to manage orders completely by the GraphQL API instead of just retrieving basic information from orders.

Laravel Octane support

Aimeos is already known for its ultra fast response times and the support for Laravel Octane in combination with Swoole or Roadrunner takes this to a new level! The Laravel and Aimeos application is always kept in memory and only the scoped services and the request object are passed to the application on each browser request. Thus, the whole bootstrapping of Laravel is only done on start-up.

Performance tests have shown that when using a Laravel Octane based setup, you can get response times down to 20ms very easily and it can triple the number of concurrent request on your existing hardware.

TYPO3 v13 support

The Aimeos TYPO3 extensions supports TYPO3 v13.4+ now, the latest LTS release of the TYPO3 CMS. It’s available as composer package, TER extension and as TYPO3 distribution. If you plan to use one or more payment providers, using the composer based package or distribution should be preferred.

As the relevant changes in TYPO v13 are supported by v12 LTS too, the new version of the Aimeos TYPO3 extension is still backward compatible to TYPO3 v12.4.x. That allows you to upgrade to the latest Aimeos release without the need to upgrade the TYPO3 CMS installation too.

Simplified managers

A lot of work has been done to simplify the managers in the Aimeos core. Before, creating a new manager using lists of referenced items and properties required writing a lot of code. Now, the code for retrieving and fetching those dependent items is part of decorator classes which can be wrapped around every manager just by configuration. For example, the decorator configuration for the product manager is now:

'mshop' => [
    'product' => [
        'manager' => [
            'decorators' => [
                'global' => [
                    'Lists' => 'Lists',
                    'Property' => 'Property',
                    'Type' => 'Type',
                    'Site' => 'Site',
                ],
            ],
        ]
    ]
]

These settings wrap the “Lists”, “Property”, “Type” and “Site” decorators around the product manager to fetch and retrieve the connected items. For managers which has addresses attached, there’s also an “Address” decorator available. Almost all managers of the Aimeos core have been rewritten to use the decorators and we were able to remove several thousand lines of code.

Improved backend and frontend

To simplify configuration of AI-based services for each site, a new sub-panel has been added to the “Settings” panel. There, site administrators can add the API keys and other relevant configuration settings for the DeepL, OpenAI and RemoveBG APIs. Configuration for other APIs can be added easily by implementing a new sub-part for the settings/api sub-panel and a custom template for the necessary fields.

Also, the product sub-panel in the catalog and supplier panels have been rewritten to support document based storage like ElasticSearch now. During that change, the filtering for items has been removed because it was based on the database queries of the lists managers, which are not available in a document-oriented storage.

The frontend got some minor improvements and a new feature for removing all items in the basket at once, so users are not required to delete every line separately any more.

The 2024.07 release completes the GraphQL API and adds some nice features to Aimeos. In addition, we’ve invested a lot of time to improve the documentation of the GraphQL and JSON APIs:

• GraphQL file uploads and new index query
• Extended GraphQL and JSON:API documentation
• Custom address types
• Full time support in subscriptions
• Multiple mailer support in Laravel

GraphQL API improvements

The GraphQL admin API will replace the existing JSON admin API completely beginning in 2025. The JS code of the Aimeos admin backend is rewritten step by step to use the GraphQL API only and thus, the GraphQL admin API has been further improved and is now almost feature complete.

The latest additions contain a new GraphQL index query that allows aggregating products matched by filters for counting or of aggregation. Also, The API supports uploading media files now – a feature, that’s not available in the the old JsonAdm API.

Until 2025, the remaining code that uses the JsonAdm API will be rewritten and the JsonAdm API will be finally removed.

API documentation

We’ve put a lot of effort in improving the API documentation for the GraphQL and JSON REST API.

Especially, the examples have been improved and they include vanilla Javascript code for the JSON API and JQAdm code the GraphQL admin API now. This enables developers of any skill level to get code for working requests quickly. Furthermore, existing examples have been improved to show how related items can be fetched too and how they are returned.

All new queries and mutations available in 2024.07 has been documented too in the GraphQL admin API and JSON REST API documentation.

Custom addess types

Up to now, it was possible to add addresses to customers and suppliers but they had a fixed meaning. For customers, the addresses are treated as delivery addresses while for suppliers, the addresses are locations for stores or with a similar meaning.

Now, the customer and supplier address tables contains a new “type” column that can contain any string to distinguish the different addresses stored there. This is especially useful in heavily customized setups which includes non-standard use cases, e.g. for complex B2B applications and marketplaces.

Time support in subscriptions

The Aimeos backend supported entering hours for subscriptions already in the past but the rest of the code wasn’t fully prepared to copy with subscriptions that should be only available for one or more hours.

Now, this feature is completely available in the whole code base including renewal of subscriptions after one hour if configured in the product subscription settings.

Multiple mailer support

In case you need to use different mail servers for sending e-mails depending on their purpose, Aimeos does support them now – at least if you are using Laravel. The mail() method of the Aimeos context object accepts the name of the mailer configuration now and returns the mailer object which uses the corresponding configuration. Existing code isn’t affected because the new parameter is optional and the default mailer is returned as before if no parameter is passed.

The first stable release of the Aimeos ecommerce framwork for Laravel and TYPO3 in 2024 offers a whole bunch of updates compared to previous versions and is prepared for the upcoming accessibility requirements in the EU. The most important features and changes are:

• Full Laravel 11 support
• WCAG AAA compatible template
• Top-level URLs for products/categories/pages
• Product CSV upload in backend and imports per site
• VueJS 3 in admin backend with locally bundled JS libs
• Improved GraphQL admin API
• Simplifications for developers

Full Laravel 11 support

The Aimeos Laravel package has support for Laravel 11 since its release a month ago. The number of breaking changes in Laravel 11 had been low so adapting the package was possible immediately.

Now, with the Aimeos 2024.04 release, the Aimeos shop distribution as well as the Aimeos headless distribution are based on Laravel 11 too. The most important change in Laravel 11 is the simplified ./app/ directory but the old structure is still supported. Only the AuthServiceProvider class isn’t used any more.

WCAG AAA compatible template

Starting in 2025, almost all companies in the EU need to have accessible web sites which can be used by handicapped persons too. The W3C Web Content Accessibility Guidelines provides useful help to comply to the required accessibility standards.

The default Aimeos theme as well as the Berlin theme for marketplaces is now prepared for WCAG 2.2 AAA. Most of the required changes related to controls, buttons and other active elements which needs to be big enough for easy usage.

Top-level URLs for categories/products/pages

The Aimeos Laravel package and the Aimeos shop distribution based on Laravel support now URL segments without sub-paths. Than means, you can have URLs like /sneakers, /nice-blue-top-sneaker and /contact as URLs for categories, products and CMS content pages.

All those top-level URLs are handled by the ResolveController, which checks if a category, product or CMS page with that URL segment exists. This feature isn’t enabled by default because it requires additional database queries to check what type of entity is assigned to that URL segment. The README of the Aimeos shop distribution contains a section how to enable the multi-routing feature.

Product CSV upload in backend and imports per site

One of the major changes in Aimeos 2024.x compared to previous versions is that CSV and XML files can now be imported per site in multi-site environments. Therefore, the files must be stored in sub-directories of the product, catalog, supplier, etc. directories named after the code of the site to import the files for within the fs-import file system.

That change allowed to implement uploading CSV files in the product list panel. Then, these files are stored in the appropriate directory of the fs-import file system and are processed by the product CSV job controller that needs to be executed regularly by a cron job because of time and memory constraints in HTTP requests.

VueJS 3 in admin backend with locally bundled JS libs

The Aimeos admin backend has been rewritten and uses VueJS 3.x for the dynamic features now. You will only notice the upgrade of the VueJS library if you have overwritten parts of the admin backend with custom templates. The code for initializing the VueJS apps must be different now as well as inline templates are not supported any more.

Instead of using the JS files from a content delivery network, they are now bundled by NPM and included from the local file system. This reduces the dependency from external CDNs, supports environment without internet connections and the bundled files are also smaller which improves the loading time.

Improved GraphQL admin API

The Aimeos GraphQL API is now almost feature complete. It can handle the necessary requests to fetch and manage all resources including the aggregations required for the dashboard. Compared to previous versions, the API supports getting the total number of items too. Only file uploads for the media resources are missing and will be added in the next version.

Beginning of 2025, the existing JSON admin API will be deprecated and removed in later versions so you should use the GraphQL API in the backend from now on. The JSON API for the frontend won’t be affected in any way and is the only supported option for fetching data for building your own frontend.

Simplifications for developers

We always work hard to make things as simple as possible for developers using Aimeos for their own projects. Creating new managers required to write a lot of code in the past but now, it has become very simple. The article about implementing new managers describes the few steps with examples that are required to create the necessary migration and the manager class which defines the properties.

In the HTML frontend, the address sections in the checkout process and the account profile page have been unified and use a common address partial now. Thus, they can be configured using the same settings now but that required renaming the existing configuration options.

To simplify the structure, the controller/common and controller/jobs code in the ai-controller-jobs extension has been merged and the controller/common code from the aimeos-core package has been moved to the media and order managers where they belong to.

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 Aimeos 2022.10 version with long term support is now available for Laravel and TYPO3. It contains a lot of improvements for customers, editors, developers and marketplace owners. The most important improvements included in this release are:

• GraphQL admin API
• Headless Laravel distribution
• Direct editing of marketplace items
• Dynamic supplier filter
• Customers can save baskets
• Invoice numbers per site
• Optimized performance
• SEO and 404 improvements

GraphQL admin API

The biggest improvement in the 2022.10 LTS realease is the GraphQL API for administration, which enables developers to manage products and other data stored in Aimeos much easier compared to the JSON REST Admin API. Especially updating several related resources can be done in one API call now instead of requiring ten or more calls. The GraphQL API is also much more aligned to document based storage like ElasticSearch.

A GraphQL mutation to store a new product and return its ID looks like:

mutation {
  saveProduct(input: {
    code: "test-graphql",
    lists: {
      media: [{
        type: "test"
        item: {
          type: "download",
          url: "https://local/test.jpg",
          preview: "https://local/test-small.jpg"
          property: [{
            type: "copyright",
            value: "Aimeos"
          }]
        }
      }],
      text: [{
        type: "name",
        item: {
          type: "name",
          languageid: "de",
          content: "Some text"
        }
      }]
    },
    property: [{
      type: "prodcode",
      value: "abcd-1234"
    }]
  }) {
    id
  }
}

Headless Laravel distribution

The Aimeos headless distribution based on Laravel 9 is now stable and available with long term support too. It’s tailored for developers who want to build the complete frontend in Javascript using ReactJS, VueJS or any other Javascript framework. For authentication, JSON Web Tokens are used in the headless distribution and the world-class Aimeos JSON REST API offers access to the complete frontend functionality of Aimeos.

Get the Aimeos headless distribution

Edit marketplace items directly

In the past, editors have to switch to the site where the texts, images, attributes or other related items had been created before they could update or delete those items. Now, editors can modify or delete every item created in a sub-site of the current one directly, which is extremely handy in marketplace setups to fix items of vendors quickly!

For all those aggregated items (and also for inherited ones) where no space for additional information is available, the Aimeos backend displays the meta data like site, editor and creation/modification time when hovering over the item now. Therefore, you can see immediately from which site the item is coming from as well as who created/modified it and when.

Dynamic supplier filter

For those who have hundreds, thousands or more suppliers/manufacturers/brands in their Aimeos installation, the new supplier filter offers searching for those items dynamically. Thus, it’s not necessary to preload a limited set of items.

The filter enable customers to search for any supplier based on their name and it also finds sub-strings in supplier names. The most often used suppliers are still listed first when opening the filter and found items are added at the top.

Customers can save baskets

Customers can save their baskets now, which is especially useful for B2B clients who have selected the products they need for their customers and store the baskets until they get the final OK. Each basket can have a name describing the content.

Then, the stored baskets are listed in the profile section of the account just like for the order history. Customers can select one of the stored baskets and put all products inside into the current basket with a single click and continuing to the checkout.

Invoice numbers per site

Especially for marketplaces and SaaS setups, separate sequential invoice numbers for each vendor are important for accounting reasons. In 2022.10, Aimeos adds an invoice ID column to the locale site table and creates a new, unique invoice ID for each order after the payment was successful.

The ID from the order table is still used to identify each order uniquely over all sites and the generated invoice ID is stored in addition in the order table. The invoice ID can also be formatted before being added to the e-mails or the PDFs by using the ordernumber marco:

use \Aimeos\MShop\Order\Item\Standard as Order;

Order::method( 'ordernumber', function( \Aimeos\MShop\Order\Item\Iface $order ) {
    return 'RE-' . date( 'Y' ) . '-' . $order->getInvoiceNumber();
} );

Optimized performance

Job controllers often iterate over a large result set and using the limit and offset values in slice() of the search filter cause long response times until the database found the requested slice. This can take several seconds if the whole result set is more than 100k rows.

For optimal performance, Aimeos offers a cursor based iterate() method in each manager now:

$manager = \Aimeos\MShop::create( $this->context(), 'product' );
$cursor = $manager->cursor( $manager->filter()->add( 'product.instock', '==', 1 ) );

while( $items = $manager->iterate( $cursor, ['price'] ) ) {
    // process items
}

The new iterate() method is most useful if you need to process a large result set completely.

Furthermore, the column order of all indexes in the Aimeos tables have been optimized to get the best performance for the most often used queries. Especially, MySQL uses more parts of the index now because it will use indexed columns in a combined index only as long as there’s no LIKE condition involved.

SEO and 404 improvements

To get the best results in Google, the schema.org markup in the list and detail views has been improved. It’s telling the search engine what’s the name, image, price and description of the product and contains now additional markup for the Google merchant listings. Furthermore, the breadcrumbs from the catalog stage component are now also machine readable for Google.

Before 2022.10, pages with no content or with invalid category/product IDs returned a page without content but no 404 error. This led to many pages without useful content being index by search engines. Now, all category list, product detail and CMS pages which are not available (any more) return a “404 not found” error.

The second stable release in 2022 contains new features and some changes/improvements for developers to keep an eye on. This version focuses on improvements for editors and on minimizing code developers have to write when creating new features in Aimeos. The most important changes are:

• Bulk editing in admin backend
• Customizable theme colors in backend
• Uses Bootstrap icons instead of Fontawesome
• No more need for factories
• Scales images in media manager
• More fractional quantity support
• Improved debugging

Bulk editing

One of the features that can simplify life of editors a lot is editing the values of several items at once. The Aimeos admin interface it’s now possible to do exactly that, not only for single values like the status, but also for multiple values in parallel with one bulk edit request.

For all panels, at least the basic item values can be changed as long as they must be not unique. You can add your own bulk edit options by extending the list template of the panel and add the additional code to subparts or decorators if required.

Customizable theme colors

Aimeos uses CSS variables to define colors and several other important values which are used at several places in the CSS files. This allows you to overwrite these values in your custom CSS file to adapt the frontend design to your needs or to the corporate identity.

In Aimeos 2022.07, you can change those variables not only globally but also per site and theme if you have several themes installed. Thus, each customer/company can select the theme and the appropriate colors themselves for their needs which makes Aimeos a perfect fit for building ecommerce SaaS solutions.

New Bootstrap icons

Up to now, Aimeos have used Fontawesome for all icons in frontend and backend. As new icons in Fontawesome are most often available only in their proprietary icon packages, there was time for choosing a new icon set. In the shop frontend, Fontawesome icons have been replaced in the 2022.04 release and now they are also gone in the admin backend.

Instead, Aimeos is using the Bootstrap icons now, giving the backend a cleaner, more lightweight look and feel that supports the colored theme available since 2021.

Removed factories

Each manager, controller and client required its own factory for creating a new object of that type. This lead to a lot of boilerplate code because the factories had mainly the same code and were just different in the used configuration options and the names of the classes. Beginning with the 2022.07 release, implementing a manager or controller for a new data domain or job as well as clients for the frontend or backend doesn’t require a supporting factory any more.

All objects are now created by the central factories only that have been available for a long time:

$manager = \Aimeos\MShop::create( $context, 'product' );
$cntl = \Aimeos\Controller\Frontend::create( $context, 'catalog' );
$cntl = \Aimeos\Controller\Jobs::create( $context, $aimeos, 'media/scale' );
$client = \Aimeos\Client\Html::create( $context, 'catalog/detail' );
$admin = \Aimeos\Admin\JQAdm::create( $context, 'product' );

Developer experience

We strive for the best developer experience possible, so working with Aimeos should be as easy as possible. In that light, there are a couple of improvements available in this release.

Instead of using the common media contoller to work with image file, the media manager is now able to do that directly by its new scale() method. It offers the same features as the controller which is going to be cleansed next year.

Ordering fractional product quantities is supported since 2020.04 but now, you can also use fractional quantities for multi-level pricing (also known as block pricing). This gives you fine-grained control over pricing of products that can be bought in quantities of less than one or non-integer quantities.

For debugging purpose, all non-item objects where decorators can be added support a classes() method since this version. Thus, you can easily find out, which class has been used for the inner object and which decorators has been wrapped around, so identifying possible issues is now easier then before.

The first stable release of the Aimeos e-commerce framework in 2022 contains a lot of exciting new features and changes compared to the last LTS version. Improving the developer experience further was one of the most important goals for this release besides more performance. All improvements are available for both, Laravel and TYPO3 and include:

• Laravel 9 LTS support
• Integrated distribution based on Laravel 9
• New Aimeos headless distribution built on Laravel 9
• Radically simplified HTML client code base
• Top scores of 100% for Google Lighthouse
• Bootstrap 5 w/o jQuery
• Upscheme migrations
• Higher performance

Laravel 9

Aimeos is the first full-featured e-commerce framework supporting the new Laravel 9 release with long term support (LTS) since beginning of April 2022. The biggest changes necessary for moving to the new Laravel release have been the migration from Swiftmailer to the Symfony mailer package and to FlySystem v3 for file access.

Together with the Aimeos Laravel 2022.04 package which can be added to every existing Laravel 9 installation, the integrated Aimeos distribution is now also based on Laravel 9 LTS. The distribution includes shop and CMS features and you can create a ready to use online shop. Simply execute this on the command line if PHP and the composer package manager are installed:

php composer create-project aimeos/aimeos myshop

In addition, there’s now a Laravel 9 based Aimeos headleass distribution available too. This distribution is especially suited for building your own progressive web application based on ReactJS, VueJS or any other JS frontend framework. It includes the admin backend and the world-class Aimeos JSON REST API but not the traditional HTML frontend. Also, it comes with the pre-configured JSON web token (JWT) package for Laravel installed for authenticating frontend users.

Developer experience

We’ve put a lot of effort into improving the experience for developers, especially the need to write less boilerplate code when implementing own HTML clients. Thus, the necessary code for adding a new HTML component in the frontend is now reduced to the bare minimum. You only need to write the code you really need now and additional methods are not required any more because there are default implementations available for them.

Additionally, the directory structure has been simplified as much as possible. Methods have been shortend and the most important ones only consists of a single word now. A few examples of renamed methods are:

• getContext() -> context()
• getBody() -> body()
• addData() -> data()
• …

For a full list of breaking changes compared to the 2021.10 LTS version, please have a look into the Aimeos changelog in the documentation.

Google Lighthouse scores

Aimeos already achieved top scores for desktops in the past but for mobile devices, the performance score reached a maximum value of 70. Several changes have increased the score to almost 100 now.

The most important change was to split up the three main Aimeos CSS and JS files into one CSS/JS file per component. Now, all CSS rules and Javascript code that is used solely by e.g. the catalog detail component has been moved the their own catalog-detail.css and catalog-detail.js file. They are only sent to the browser if the catalog detail component is used at the requested page. Therefore, the browser doesn’t need to fetch and parse unused CSS/JS code any more which can shorten page loads drastically especially on slow devices/networks.

Furthermore, the used Slick slider contains a lot of JS code which is executed after the document is fully loaded. This increases the “time to interactive” until the users can interact with the page but it’s a crucial value for Google Lighthouse and heavily affects the score. Now, Aimeos uses SwiffySlider, a slider based on CSS animations with only very little JS code. It’s feature-rich, supports touch out of the box and has very little negative effect on performance.

Bootstrap / jQuery

Bootstrap 5 has been used in the backend since 2021.04 and now, the default frontend theme has switched to Bootstrap 5 too. This allowed us to dump the jQuery library in favor of vanilla Javascript but that turned out to be much more code than before. Here’s a code example for jQuery and vanilly JS:

// jQuery
$('.class')

// vanilla JS
document.querySelectorAll('.class')

Vanilly JS is rather inconvenient compared to the terse code you can write with jQuery. To get short code without the bloat of jQuery, we now use the Cash DOM library as instead. It offers the same syntax as jQuery for the “$” function and the collection methods but doesn’t contain the compatibility code for old browsers and uses native browser functionality instead. It also requried to use the new JS fetch API offered natively by modern browsers instead of the jQuery get()/post() methods.

Upscheme migrations

Since 2022.01, Aimeos uses Upscheme for migrating the database schema and the data itself. Compared to using Doctrine DBAL directly, this reduced the required lines of code drastically up to 80% and creating/updating a table now looks like:

$this->db( 'db-message' )->table( 'message', function( Table $t ) {
        $t->id();
        $t->type();
        $t->string( 'label' );
        $t->bool( 'status' );
        $t->meta();
} );

All setup tasks are now located in the setup directory of the Aimeos core and the Aimeos extensions. There’s already an Upscheme article available which explains how to implement setup tasks in Aimeos 2022.x and later.

Performance

To increase performance of Aimeos further, the underlying data structure has been modified. Before, products has been referenced in the mshop_catalog_list table by categories and in the mshop_supplier_list table by suppliers. This required fetching categories and suppliers for products in two separate queries and especially for document-oriented storages like ElasticSearch, it enforced updating the documents two times.

Now, categories and suppliers are attached to products instead of the other way round, so only one additional query per domain is needed to fetch that data for the frontend. It’s now perfectly in line with document-oriented storages can reduce indexing time drastically.

Since 2022.01 beta, the Aimeos core is using Upscheme for updating the database schema and migrating data between new releases. Upscheme is composer package for schema management based on Doctrine DBAL which offers an easy to use API. You can also integrate Upscheme it in your own application easily and this article explains the differences and how you can write migrations with only a few lines of code

Why Upscheme

Whenever you need to upgrade database schemas in more than one installation and your application supports more than one database (even MySQL and MariaDB differ in some details), you need a tool for schema management. And even if you only support one database vendor, it simplifies live because you don’t have to create messy custom scripts with raw SQL statements.

Aimeos used the Doctrine DBAL API directly up to 2021.10 LTS but DBAL has a very verbose API and requires a lot of code to do simple things. For example, creating/updating a table usually looks similar to these lines:

$dbalManager = $conn->createSchemaManager();
$from = $manager->createSchema();
$to = $manager->createSchema();
 
if( $to->hasTable( 'test' ) ) {
	$table = $to->getTable( 'test' );
} else {
	$table = $to->createTable( 'test' );
}
 
$table->addOption( 'engine', 'InnoDB' );
 
$table->addColumn( 'id', 'integer', ['autoincrement' => true] );
$table->addColumn( 'domain', 'string', ['length' => 32] );
 
if( $conn->getDatabasePlatform()->getName() === 'mysql' ) {
	$table->addColumn( 'code', 'string', ['length' => 64, 'customSchemaOptions' => ['charset' => 'binary']] );
} else {
	$table->addColumn( 'code', 'string', ['length' => 64]] );
}
 
$table->addColumn( 'label', 'string', ['length' => 255] );
$table->addColumn( 'pos', 'integer', ['default' => 0] );
$table->addColumn( 'status', 'smallint', [] );
$table->addColumn( 'mtime', 'datetime', [] );
$table->addColumn( 'ctime', 'datetime', [] );
$table->addColumn( 'editor', 'string', ['length' => 255] );
 
$table->setPrimaryKey( ['id'] );
$table->addUniqueIndex( ['domain', 'code'] );
$table->addIndex( ['status', 'pos'] );
 
foreach( $from->getMigrateToSql( $to, $conn->getDatabasePlatform() ) as $sql ) {
	$conn->executeStatement( $sql );
}

Contrary, Upscheme offers a very terse API which does the same in only a few lines of code:

$this->db()->table( 'test', function( $t ) {
	$t->engine = 'InnoDB';
 
	$t->id();
	$t->string( 'domain', 32 );
	$t->string( 'code', 64 )->opt( 'charset', 'binary', 'mysql' );
	$t->string( 'label', 255 );
	$t->int( 'pos' )->default( 0 );
	$t->smallint( 'status' );
	$t->meta();
 
	$t->unique( ['domain', 'code'] );
	$t->index( ['status', 'pos'] );
} );

Upscheme also offers much better support for migrating data. Instead of using a “migration” table to keep track executed migrations which can get out of sync, Upscheme checks the current state of the schema and applies only necessary changes to update the tables, columns and other schema objects.

If your application allows 3rd party plugins you will love Upscheme’s dependency management based on tasks that must run before or after the current one. Thus, extensions can modify existing tables and migrate data without interfering with core tasks.

Create/update database schema

Creating and updating a table for example requires:

• an Upscheme task
• the table definition

The code below creates an Upscheme task named “Messages” by extending from the Upscheme base task and implements the up() method which is executed to perform the schema update:

namespace Aimeos\Upscheme\Task;
use Aimeos\Upscheme\Schema\Table;
 
class Messages extends Base
{
    public function up()
    {
        $this->db( 'db-message' )->table( 'message', function( Table $t ) {
                $t->id();
                $t->type();
                $t->string( 'label' );
                $t->bool( 'status' );
                $t->meta();
        } );
    }
}

Within the up() method, the database schema for the “db-message” database is retrieved (with a fall-back to the standard database if “db-message” isn’t explicitely configured) and the “message” table defined. It consists of an “id” autoincrement integer column (with primary key), a label and status column as well as “ctime”, “mtime” and “editor” columns automatically added by the meta() function offered by the Aimeos core.

The Table section in the Upscheme documentation contains the list of pre-defined methods for creating the most often used column types. Nevertheless, you can always use the Upscheme col() method to create custom columns too and there’s also a list of Upscheme column modifiers to customize any column according to your needs.

Whenever you add, change or remove a column in your task, Upscheme will update your table schema automatically without any need to write an additional line of code!

Migrate data

Upscheme tasks can also migrate data between new releases and offers simple methods to insert, update and delete records. Also, there are methods available to check for tables, columns and other schema object, to rename them and to drop them if they are not required any more:

$this->db()->delete(
    'message',
    ['type' => 'custom']
)->dropColumn(
    'message',
    'type'
)->update(
    'message',
    ['status' => false],
    ['status' => true, 'mtime' => date('Y-m-d H:i:s')]
)->renameColumn(
    'message',
    'label',
    'content'
)->insert(
    'message',
    ['label' => 'test message', 'status' => true, 'ctime' => date('Y-m-d H:i:s'), 'mtime' => date('Y-m-d H:i:s'), 'editor => 'setup']
);

This statements will delete the messages of type “custom”, drop the messages column afterwards, set the status to TRUE of all remaining records which updating the “mtime” column, rename the “label” column to “content” and insert a new test message into the table. All method calls can be concatenated because the Upscheme API offers a fluent interface and there’s also a select() method to query data:

$this->db()->select(
    'message',
    ['status' => false, 'type' => 'old']
);

For more complex statement, Upscheme provides the stmt() method which gives you direct access to the Doctrine DBAL API:

$result = $this->db()->stmt()->select( 'id', 'content' )
    ->from( 'message' )
    ->where( 'status = 1' )
    ->execute();
 
while( $row = $result->fetchAssociative() ) {
    $map[$row['id']] = $row['content'];
}

Summary

Compared to Doctrine DBAL, Upscheme is very easy to use and also contains some workarounds for pitfalls in DBAL. Creating and updating the database schema is extremely simple and Upscheme saved up to 80% of the code in some setup tasks compared to the previous DBAL code in the Aimeos core.

The 2021.10 release of the Aimeos e-commerce framework with long term support is available for Laravel, Symfony and TYPO3. It contains a lot of small features repeatedly requested by developers and users and which improve user experience, usability for editors and security. The most important improvements are:

• Laravel 8 distribution and TYPO3 11
• Radius search and maps
• “Price on request” feature
• Product video support
• Improved backend usability
• Custom invoice numbers
• Warehouse management
• PDF with SEPA QR-code and images
• Strict CSP and other improvements

Laravel 8 distribution and TYPO3 11

After Laravel 9 has been postponed to next year, we’ve decided to update the Aimeos standalone shop distribution to Laravel 8 in the meantime. Up to now, the Aimeos distribution was based on Laravel 6 LTS for maximum stability and we will upgrade to Laravel 9 LTS beginning with Aimeos 2022.04+ releases.

Despite of that, the Aimeos Laravel package is available for Laravel 8 since it was released and will be also available for Laravel 9 immediately after its release.

The Aimeos TYPO3 extension is the most widely used e-commerce extension for TYPO3 and even surpassed tt_products this year according to the TER download numbers!

The Aimeos 21.10 LTS release contains full support for TYPO3 11 and also the 1-click Aimeos TYPO3 distribution is available for TYPO3 11.5 LTS since its release.

Radius search and maps

The Aimeos admin backend contains world maps in the customer and supplier panels now, so editors can select or update the coordinates the addresses belong to. Then, supplier coordinates are added to the product index to enable users searching product within a given radius.

The maps in the backend are generated by Leaflet.js and OpenStreetMap and can be used by anyone without fees.

Price on request

One of the most often requested features, especially in the B2B area, is the ability to create a request for the products in the basket without displaying a price. Then, the price is caculated by different factors and printed at the offer sent to the customer.

If editors add prices with empty values to products, the frontend will display “on request” now. Customers can add those products to the basket and can complete the order as normal but the products without a price will be treated like having a price of 0.00.

Mixing products with a regular price and products with prices “on request” is no problem and the payment at the end of the checkout process will be done for the products with a regular price only.

Product video support

The release also includes support for product videos in MP4/WebM format. You can upload one or more videos in the product media panel of the admin backend and a preview image is generated automatically based on the video content.

The videos are shown like regular product thumbnails in the catalog detail component of the HTML frontend but if users switch to the video, it starts playing automatically without sound.

Improved backend usability

To ease daily work for editors, all media panels now support uploading multiple files at once when clicking on the “+” button and each file will create a new card automatically. Before, only the card was added and you had to upload a file for each card. Also, the new release improves cropping and scaling of uploaded images.

In the text panels, CKEditor 5 is now used for editing and styling the text content. The new version also added new features like table and video support within texts which is now available out of the box.

Custom invoice numbers

Many shop owners want to customize the invoice numbers for many reasons but this was hardly possible in the past. Now, developers can register custom functions for generating invoice numbers that are used in the HTML frontend, the e-mails or PDFs, e.g.:

use \Aimeos\MShop\Order\Item\Standard as Order;
 
Order::method( 'ordernumber', function( \Aimeos\MShop\Order\Item\Iface $order ) {
    return 'RE-' . date( 'Y' ) . '-' . $order->getId();
} );

Warehouse management

To improve order and warehouse management in Aimeos, there’s a new payment status for each ordered product. Thus, you can now mark single products as refunded or use any other payment status.

To display the additional information, the product section of the order detail panel has been rewritten. It’s fully responsive now and easy to use in combination with mobile phones.

For the 2022.x version, you can expect some bigger changes in the Aimeos order domain.

PDF with SEPA QR-code and images

The template for the PDF attached to the payment related e-mails contains a QR-code for European IBAN payments. Mobile users whose bank supports scanning these QR-codes can pay invoices within seconds and 100% error free.

In addition, the template also contains example code how to add a background image to the PDF files. Then, companies can send order confirmations including PDFs that look exactly like their well-designed letter papers.

Strict CSP and other improvements

Starting with 2021.10 LTS, a strict Content Security Policy has been implemented for the Aimeos backend and for the Laravel frontend. This effectively prevents Cross-Site-Scripting (XSS) where foreign Javascript code is executed in the context of the page loaded by the users’ browser and which is a common source of security incidents.

This also means that inline Javascript in any templates is ignored by browsers now and scripts, CSS, images, videos, etc. are only loaded from well-defined sources. To allow a new URL for any of those objects, you have to overwrite the frontend or backend page template and add the URL there:

• Laravel frontend
• Laravel backend
• TYPO3 backend

To allow Javascript required by e.g. payment gateways like Stripe, a “nonce” is available to mark JS code within script tags as trusted. Other security improvements include hardening against potential CSRF attacks and SVG images are now sanitized when uploaded, so they doesn’t contain any Javascript or external URLs.

To improve internationalization, it’s now possible to translate all error messages with placeholders from the core, even those that are only logged. Furthermore, all log messages has been categorized to filter messages by their source effectively.

Last but not least, the catalog detail component can be configured to return a HTTP 404 status instead of displaying an error message that the product could not be found.