Showing results 251 to 275 of 1561

Task
Under Review Quiet Backend User Interface TYPO3 CMS 15

#110818 Improve modal messages in "History/Undo" feature

The modal window in “History/Undo” has always the same text, but it is invoked via
three different action buttons:

“Rollback single field“
“Rollback single record“
“Rollback all changes shown”

with this patch a different message is shown for each action

Criteria followed to improve the labels:

- removed phrasing like “Are you sure…“
- consistent use of “Roll back” as action (verb) vs “Rollback” as noun

Author Riccardo De Contardi
Created 09/28/26, 15:03
Updated 09/29/26, 13:24
Feature
Under Review Quiet DataHandler aka TCEmain

#104740 Exclude tables when copying a page record in the backend

When a page is copied, all tables that the current user has access to are copied.
For an admin, array_keys($GLOBALS[‘TCA’]) is used to determine the list of tables to copy.
When an extension creates log records, e.g. for form submissions, this may lead to errors or copying a lot of records that should rather be skipped.

You might argue that you can make the storage page configurable, but then the user needs to take care of that as well – or you will probably store the logs of two different forms in the same storage record.

Thus i’d like to propose either a new TCA setting that can then be used to filter the result of \TYPO3\CMS\Core\DataHandling\DataHandler::getAllowedTablesToCopyWhenCopyingAPage so that you can easily skip all those log tables etc. by configuration, or an event that gets the $copyTablesArray handed over.

Author Andreas Kießling
Created 08/26/24, 21:54
Updated 09/29/26, 12:38
Bug
Needs Feedback Quiet Backend User Interface TYPO3 CMS 14

#110672 Filelist "Create metadata of this file for X" fails for non-admin users ("No source languages available")

Environment: TYPO3 14.3, Composer-based installation, 2 site languages configured (default + 1 additional), both enabled, no language restriction on the backend user group (“Limit to languages” empty).

Steps to reproduce:

Log in as a non-admin backend user with tables_modify permission on sys_file_metadata and edit rights on the relevant file mount.
Filelist module → open a folder containing a file that has no metadata translation yet for the additional language.
Click “Create metadata of this file for <language>“ in the per-file language dropdown.<br>The record localization wizard opens; step 2/6 “Select source language” always shows “No source languages available”, regardless of how many/which languages are configured.</language>

If the exact same steps are performed as an admin user, the wizard works correctly and creates the translation without issues.

Expected behavior: Non-admin editors with the correct table/file permissions should be able to create the first metadata translation for a file, same as admins.

Actual behavior: Only admin users can ever get past step 2 of the wizard for this action.

Root cause analysis:

sys_file_metadata records live at pid=0. The record localization wizard’s language-resolution step performs an implicit page-permission check against this pid. Since pid=0 is a pseudo-page that never has an explicit permission row and cannot be granted permissions through the normal page-permission UI, only admin users (who bypass all permission checks entirely) ever satisfy this check. A non-admin user can never be granted access to it, regardless of their language permissions, file mount, or table permissions.

Note that “Edit metadata of this file for <language>“ for an already existing translation works correctly for non-admins, since that action links directly to the FormEngine edit route (record_edit) rather than going through the localization wizard. So this is specifically about the wizard’s page-permission gate on pid=0, not a general sys_file_metadata ACL problem.</language>

Practical impact: on any multi-language TYPO3 site, non-admin editors can never create the first translation of a file’s metadata through the core Filelist UI — this has to be done by an admin, or worked around by creating the record programmatically (e.g. via a PSR-14 listener on AfterFileMetaDataCreatedEvent).

Related issues: #92906, #105824

Author burkhardt wenzel
Created 09/10/26, 14:43
Updated 09/28/26, 19:40
Bug
Under Review Quiet FormEngine aka TCEforms TYPO3 CMS 14

#110506 TCA ignoreWebMountRestriction is not respected in BackendModule

When using the Viewhelper be:uri.editRecord in a backend module to jump into edit form of a record, the TCA option ignoreWebMountRestriction is not evaluated. Records outside the Webmount can not be edited.

*My Setup is*
- TYPO3 14.3.6
- PHP 8.4.22
- DB Driver pdo_pgsql (should not be relevant, just mention this as it is not standard in my setup)

*Reproduce*
- Custom record which is stored on the startpage (root of pagetree, uid 1 in my case)
- TCA with ctrl->security->ignoreWebMountRestriction set
- TCA has ctrl->rootLevel = 0, just to make sure the record is not saved on root
- a backend module with an edit button which points to a record (or new record) as described in Documentation https://docs.typo3.org/m/typo3/reference-coreapi/14.3/en-us/ApiOverview/Backend/UriBuilder.html
- login with a backend user who is no admin and does not have the startpage mounted in his pagetree, but has access granted to backend module and custom record

*Error*
When clicking the edit button, the edit form is not loaded. Instead 2 error messages appear.

Sorry, you didn't have proper permissions to perform this change.
No content edit permission for user 9 on page 1
Edit form could not be loaded
The edit form could not be loaded for the requested records. This might be due to insufficient permissions.

The error is thrown in TYPO3\CMS\Backend\Form\FormDataProvider\DatabaseUserPermissionCheck

// A non page record is edited.
// If there is a parent page row, check content edit right of user
$userPermissionOnPage = new Permission($backendUser->calcPerms($result['parentPageRow']));
if (!$userPermissionOnPage->editContentPermissionIsGranted()) {
  $exception = new AccessDeniedContentEditException(
    'No content edit permission for user ' . $backendUser->user['uid'] . ' on page ' . $result['parentPageRow']['uid'],
    1437679657
  );
}

but actually comes from TYPO3\CMS\Core\Authentication\BackendUserAuthentication->calcPerms. There is a check for webMount

        // Return 0 if page is not within the allowed web mount
        if (!$this->isInWebMount($row, '', $useDeleteClause)) {
            return Permission::NOTHING;
        }

but this uses pid of the record and the actual webmounts and does not check ignoreWebMountRestriction.
My expectation would be, that the editForm is displayed.

When clicking the edit button as an admin, everything works as exspected. The edit form is shown and changes can be saved.

*Solution*
IMHO there should be a check with TcaSchemaCapability::RestrictionWebMount, but unfortunately there is no information about the current table available, so a fix has a bigger scope. As calcPerms is used quite often in the core, I feel not very confident to fix this by myself.

I created a workaround posted as comment.

Author Tim Horstmann
Created 08/20/26, 12:35
Updated 09/27/26, 13:40
Bug
Under Review Quiet Content Security Policy TYPO3 CMS 13

#110172 CSP backend module: JS error "uuids is not iterable" when applying a mutation suggestion that already has a resolution

In the CSP backend module (Content Security Policy reports), clicking the “Apply” button on a mutation suggestion can throw an unhandled JavaScript error:

Uncaught (in promise) TypeError: s.uuids is not iterable (cannot read property undefined)

Root cause:

CspAjaxController::mutateReportAction() contains an early return that responds with an empty JSON body when a resolution with the same summary already exists, or when the initiating reports cannot be found anymore:

    // typo3/sysext/backend/Classes/Security/ContentSecurityPolicy/CspAjaxController.php
    $resolution = $this->resolutionRepository->findBySummary($summary);
    $reports = $this->reportRepository->findBySummary(...$initiators);
    if ($resolution !== null || $reports === []) {
        return new JsonResponse(); // <-- no "uuids" key
    }
    // ...
    return new JsonResponse(['initiators' => $initiators, 'uuids' => $reportUuids]);

The client side does not guard against this case and spreads the missing property unconditionally:

    // typo3/sysext/backend/Resources/Public/JavaScript/security/element/csp-reports.js
    invokeMutateReportAction(report, suggestion) {
        // ...
        .then(response => response.resolve('application/json'))
        .then(data => this.filterReports(...data.uuids)); // <-- data.uuids is undefined
    }

Reproduce:

  1. Enable CSP handling for a site so that violation reports are collected.
  2. In the CSP backend module, select a report and apply a mutation suggestion (e.g. AssetHandler@wildcardHost for an external domain) – this creates a row in sys_csp_resolution.
  3. Trigger/keep further reports with the same summary (or simply keep the stale report rows in the list) and click “Apply” on the same suggestion again.
  4. The AJAX endpoint returns [] (empty JsonResponse), and the module throws TypeError: s.uuids is not iterable in the browser console.

Observed:

  • Unhandled promise rejection in the browser console.
  • The report list is not updated; there is no user feedback whatsoever, so it looks like applying the exception silently failed – even though the resolution already exists and is active.

Expected:

  • No JS error. The client should tolerate a response without “uuids” (e.g. data.uuids ?? [] ), and/or the controller should always return a consistent shape ( ['uuids' => []] ).
  • Ideally the user gets a notification for this case, e.g. “This mutation has already been applied”, since the current behavior gives no feedback at all.

Suggested fix:

Either (or both):

  1. csp-reports.js : this.filterReports(...(data.uuids ?? [])) – same guard for the muteReport and deleteReport handlers, which share the pattern.
  2. CspAjaxController::mutateReportAction() : return new JsonResponse(['uuids' => []]) instead of an empty response, so the contract of the endpoint stays stable.

Additional note:

handleReportAction() has a similar edge case: when the report is not found it returns an empty JsonResponse, which is then assigned to this.suggestions and would break this.suggestions.map(...) during rendering.

Author Andreas Stephan
Created 07/08/26, 13:12
Updated 09/25/26, 13:18
Bug
Under Review Quiet TYPO3 CMS 13

#110790 Sudo mode dialog shows "bad-request" when the claim has expired

Problem

When the sudo mode password dialog stays open for more than five minutes and the password is submitted afterwards, the dialog shows the raw string “bad-request” in a red box. The password field and the Verify button stay active, but every further submit shows the same string.

Steps to reproduce

  1. Open a backend action that requires sudo mode, for example granting permissions in the access module, or any route with the sudoMode option.
  2. Wait until the password dialog is shown, then leave it open for more than five minutes.
  3. Enter the user password and click Verify.

Observed behaviour

A red box with the text “bad-request” appears above the password field. The form stays usable, but every retry ends with the same text. There is no hint that the confirmation is gone and that the action has to be started again.

Expected behaviour

The dialog tells the user that the confirmation has expired, hides the password field, and offers only a Cancel button. Closing the dialog lets the user start the action again.

Cause

A claim lives for 300 seconds (AccessFactory::DEFAULT_CLAIM_LIFETIME). After that, SudoModeController::verifyAction() cannot resolve the claim and answers with the JSON message bad-request and status 400. The dialog in sudo-mode.ts looks up messages as label keys and prints unknown keys as they are. The label verificationExpired (“Confirmation has expired. Please try again.”) and the fatal error state of the dialog already exist, but only the server rendered error route uses them. The AJAX path never reaches them.

Fix

  • The verify endpoint answers with verificationExpired instead of bad-request.
  • The dialog switches to its fatal error state on that answer and replaces the Verify button with Cancel.
Author Wolfgang Klinger
Assigned to Wolfgang Klinger
Created 09/25/26, 07:44
Updated 09/25/26, 07:49
Bug
Under Review Quiet TYPO3 CMS 13

#110700 Filelist: MP4 files render with no preview and no fallback mimetype icon in tile view

In the tile view of the Media (filelist) module, video files produce an image tag whose source is the video file itself. Instead of an fallback mimetype icon or a preview image. Other file types in the same folder behave correctly: .txt and .html receive their mimetype icons, JPEGs receive a generated thumbnail, folders receive the folder icon.
>

Steps to reproduce

  • Open the TYPO3 backend and go to the Media module
  • Select a filemount (reproduced on user_upload)
  • Switch the view to tiles
  • Upload an MP4 file into the folder
  • Observe the empty tile; inspect its markup in the browser dev tools

Actual result:

An element with the video file as src and width=“0” height=“0”, rendering as an empty tile.

Expected result:

The tile shows a generated preview frame, or a video mimetype icon, or at least a generic fallback icon (see test.null in the screenshot).
The src never points at a non-image binary, and the tile keeps its normal dimensions.

Author Marc Willmann
Created 09/14/26, 12:05
Updated 09/23/26, 00:00
Bug
New Stale TYPO3 CMS 14

#110755 Custom sys_file_metadata relations are skipped in the file reference count

Maybe “Bug” is not the right tracker, but here goes. Pretty much since ever (at least since TYPO3 8) references from sys_file to sys_file_metadata were skipped for counting references. The code responsible (EXT:filelist/Classes/FileList.php) describes in its function getFileReferenceCount:

> Counts how often the given file is referenced. This is done by looking up the file in the “sys_refindex” table, while excluding sys_file_metadata relations as these are no such references.

While this kind of makes sense (since any file edited gets this reference and usually users don’t care about that reference), this has one caveat: If an extension (e.g. EXT:poster_image) extends sys_file_metadata and adds an url type field to it, it is not counted as a reference and other extensions copying/relying on that counting technique (e.g. EXT:wv_file_cleanup) have false positives in determining the files to be deleted. What makes this a little more confusing: If you click on the reference count of a file with actual references (opening an overlay of the file) and scroll down, said sys_file_metadata reference is listed again next to the actual references which just feels inconsistent.

I am not sure what’s the right approach to this: Either sys_file_metadata references should be filtered out more strictly (only if field is set to file) or this reference shouldn’t be listed in the overlay. Depending on what’s the right approach moving forward, EXT:filelist and possibly third party extensions might need to be adapted in that regard.

Author Kevin Meier
Created 09/20/26, 20:25
Updated 09/20/26, 20:25
Feature
Needs Feedback Stale DataHandler aka TCEmain

#110542 Add enableHistory flag to DataHandler

Hello,

in one of my projects we import a large amount of records into TYPO3 and dataHandler is being used to store this data into the database. We found, that it started to flood the sys_history table.
For us the easiest way would be to simply set a flag $enableHistory, the same like with $enableLogging, that allows us to skip the sys_history writes on import.

For version 13 I already created a patch locally, which works for our needs:

--- a/Classes/DataHandling/DataHandler.php
+++ b/Classes/DataHandling/DataHandler.php
@@ -125,6 +125,13 @@
     public bool $enableLogging = true;

     /**
+     * If TRUE, changes are recorded to sys_history for undo/history purposes.
+     * Set to FALSE for high-volume programmatic imports where a full undo
+     * trail is not needed and would otherwise flood sys_history.
+     */
+    public bool $enableHistory = true;
+
+    /**
      * If TRUE, the datamap array is reversed in the order, which is a nice thing if you're creating a whole new
      * bunch of records.
      */
@@ -7865,11 +7872,35 @@
     protected function getRecordHistoryStore(): RecordHistoryStore
     {
+        if (!$this->enableHistory) {
+            return new class extends RecordHistoryStore {
+                public function addRecord(string $table, int $uid, array $payload, ?CorrelationId $correlationId = null): string
+                {
+                    return '';
+                }
+                public function modifyRecord(string $table, int $uid, array $payload, ?CorrelationId $correlationId = null): string
+                {
+                    return '';
+                }
+                public function deleteRecord(string $table, int $uid, ?CorrelationId $correlationId = null): string
+                {
+                    return '';
+                }
+                public function undeleteRecord(string $table, int $uid, ?CorrelationId $correlationId = null): string
+                {
+                    return '';
+                }
+                public function moveRecord(string $table, int $uid, array $payload, ?CorrelationId $correlationId = null): string
+                {
+                    return '';
+                }
+            };
+        }
         return GeneralUtility::makeInstance(
             RecordHistoryStore::class,
             RecordHistoryStore::USER_BACKEND,
             (int)$this->BE_USER->user['uid'],
             (int)$this->BE_USER->getOriginalUserIdWhenInSwitchUserMode(),
             $GLOBALS['EXEC_TIME'],
             $this->BE_USER->workspace
         );
     }

Might that be something we can include into the core of v13 upwards? If yes I can try to create a change request for v13, v14 and main

Author Pascal Galle
Created 08/27/26, 13:32
Updated 09/17/26, 20:55
Bug
Under Review Stale Install Tool TYPO3 CMS 11

#103201 processor_stripColorProfileParameters "-strip" does not work anymore due to additional *

After TYPO3 11.5.35 the configuration value -strip to strip the color profile is not working anymore due to additional * in configuration.

Configuration:

'GFX' => [
        'processor' => 'GraphicsMagick',
        'processor_stripColorProfileParameters' => [
            '-strip',
        ],
    ],

In the backend configuration module, it seems that typo3 always add * to the configuration, which is maybe the mistake:

Image processing testing with ImageMagick (somehow works):

Image processing testing with GraphicsMagick (fails):

Due to the * parameter after -strip the processing fails.

(Also with latest TYPO3 12)

Author Patrick Lenk
Created 02/26/24, 11:52
Updated 09/16/26, 20:49
Task
In Progress Stale TYPO3 CMS 15

#109879 Support worker mode (FrankenPHP)

Author Jochen Roth
Created 05/27/26, 19:37
Updated 09/14/26, 19:44
Feature
Needs Feedback Stale

#110646 Custom User Setting with exclude => true has no possibility to enable it for user group

In the Backend User Group i cannot enable an user setting having ‘exclude’ => true set in the TCA

Author Daniel Diesenreither
Created 09/07/26, 10:17
Updated 09/14/26, 19:35
Bug
New Stale Backend User Interface TYPO3 CMS 13

#109450 UX: Bad Visual Representation of Hidden Inline/File Reference

The current visual behavior for hidden inline or file references is unclear for editors.
When a reference is hidden in previous versions, the entire row — including the control elements — received an opacity.

Now, due to some changes to HTML and CSS, only background-color and border-style changes.
This makes it difficult to distinguish between disabled and active elements.
On dark scheme the expierence is even worse.

Current screenshot:

Improvement:
Bring back the opacity AND do not apply this opacity to the control buttons

Expected Behavior:
Only the panel header button of the hidden reference should have reduced opacity of 0.5.

This change would make it clearer that only the reference itself is hidden, not the available actions.

Related issues:
#106744 (opacity only for header button)
#107650 (here something got lost)

Author Henrik Ziegenhain
Created 04/01/26, 08:05
Updated 09/14/26, 15:28
Bug
Under Review Stale DataHandler aka TCEmain TYPO3 CMS 13

#96215 Display Condition HIDE_FOR_NON_ADMINS makes DataHandler wrongly treat these fields as access-restricted even when bypassAccessCheckForRecords is enabled

The solution for #87100 changed the DataHandler to respect HIDE_FOR_NON_ADMINS when building the excludedTablesAndFields array.

We have a field that is configured this way:
  • exclude => true (to hide them for non-admin)
  • we give editors edit permission to these fields (so that editor-induced editing works via script-induced DataaHndler calls, for the subset of editors that have the edit rights for these fields)
  • HIDE_FOR_NON_ADMINS to not show these fields in regular list/edit module, but only make them available in our custom module

Because: we have a custom Backend Module for editors to edit these fields in a controlled distraction-free way.

This does not work on v10 anymore becasue of the now-respected HIDE_FOR_NON_ADMINS

This is a breaking change that was not documented at all.

When setting explicitly $dataHandler->bypassAccessCheckForRecords = true; then I expect that the access checks are bypassed completly. The new behaviour adds access restriction that are not “by-passable” by bypassAccessCheckForRecords.

Important: the setting is called “HIDE for”, not “RESTRICT for” and is just a displayCond (conditional display , not conditonal access )..

Author S P
Created 12/03/21, 10:12
Updated 09/04/26, 07:25
Task
Under Review Stale TYPO3 CMS 15

#110636 Inject mail services into SystemStatusUpdateTask

SystemStatusUpdateTask currently resolves TemplatedEmailFactory and
MailerInterface at runtime through GeneralUtility::makeInstance().

Replace these service-locator calls with constructor injection. Since the
reports extension can be installed without the Scheduler extension, register
the task conditionally when Scheduler services are available.

Add a functional test confirming that TaskService can create the task using
the dependency injection container.

Author Wouter Wolters
Assigned to Wouter Wolters
Created 09/06/26, 08:30
Updated 09/06/26, 09:27
Bug
Under Review Stale DataHandler aka TCEmain TYPO3 CMS 14

#110206 Switching between NULL and 0 is not persisted for nullable selectSingle fields

A nullable selectSingle field cannot be changed directly between NULL and 0.

Database:

price_type int(11) unsigned DEFAULT NULL,

TCA:

'price_type' => [
    'exclude' => true,
    'label' => 'Price type',
    'config' => [
        'type' => 'select',
        'renderType' => 'selectSingle',
        'minitems' => 1,
        'maxitems' => 1,
        'nullable' => true,
        'default' => null,
        'items' => [
            ['label' => '', 'value' => null],
            ['label' => 'Regular', 'value' => 0],
            ['label' => 'Member', 'value' => 1],
            ['label' => 'Special', 'value' => 2],
        ],
    ],
],

Open the record in the TYPO3 backend and save the following changes.

Does not work (no changes are persisted):

NULL -> 0
0 -> NULL

Works as expected:

NULL -> 1
1 -> NULL

0 -> 1
1 -> 0

NULL -> 2
2 -> NULL

0 -> 2
2 -> 0

Only switching directly between NULL and 0 and vice versa does not persist the change. But changing the selected value from NULL to 0 and vice versa should be detected as a change and persisted correctly.

Author Jan Kornblum
Created 07/16/26, 09:06
Updated 09/03/26, 06:11
Bug
New Stale Extbase TYPO3 CMS 8

#83433 selectMultipleSideBySide allow items mutiple times

I made a TCA config to allow items mutiple times via the option ‘multiple’ => 1.

The config looks like this:

'type' => 'select',
'renderType' => 'selectMultipleSideBySide',
'foreign_table' => 'tx_testmultiple_domain_model_condition',
'MM' => 'tx_testmultiple_test_condition_mm',
'MM_hasUidField' => true,
'size' => 10,
'autoSizeMax' => 30,
'maxitems' => 9999,
'multiple' => 1,

In the backend I can add items multiple times but when I’m trying to get all items in the frontend all duplicate items are removed.
Is this a bug or do I need additional configurations?

I made a litte extension for testing:
http://hosting8098.af933.netcup.net/test/test_multiple_1.0.0_201712271223.zip
Same problem exists in TYPO3 7.6 also.

Author Stephan Bauer
Created 12/27/17, 13:54
Updated 09/02/26, 13:21
Task
Under Review Stale Database API (Doctrine DBAL) TYPO3 CMS 15

#110427 Rework the database analyzer stack onto objects

The core of the epic. See the epic description for the problem statement. The stack is reworked around objects, and the table becomes the unit of both analysis and application.

This is one change on purpose – the intermediate steps carry little value on their own and mostly confuse.

The analyzer

  • The comparison is built in one pass and returned as an immutable Dto\SchemaComparison, instead of being assembled by rewriting a doctrine SchemaDiff in place. The doctrine diff is used as it is, and what TYPO3 needs on top of it lives next to it: TableRename names the target of a table renamed to the deletion prefix, and the changed table options are a map next to the altered tables. The three in place migrate methods collapse into one rebuildTableDiff(), which undoes the rename doctrine guesses for an added and a dropped column that only differ by name – with partial ext_tables.sql files that guess is wrong far more often than it is right – and turns a dropped column without the deletion prefix into a rename to it.
  • ChangeType and ChangeSafety replace the operation key strings and are the single source of truth for the safe and destructive classification. RemovalMode names the two steps a removal takes: what is no longer expected is first renamed to the zzz_deleted_ prefix, which keeps its data, and only what already carries that prefix is dropped.
  • Dto\SchemaChange, Dto\TableChangeSet, Dto\SchemaChangeSet, Dto\SchemaOperation and Dto\ApplyResult describe what a change does. A change carries a list of statements, because a platform that cannot alter a table in place expresses one change as a copy, drop, create and copy-back sequence. TableChangeSet enforces in its constructor that a set is either entirely safe or entirely destructive.
  • SchemaMigrator::analyze(), apply() and applySafe() are the counterpart. A change set is applied as one unit – if a statement fails, the remaining statements of that set are skipped and the set is reported as failed, instead of being left half applied.
  • The security measure of the install tool now holds by construction rather than by convention: apply() re-derives the change sets and only intersects them with the given hashes, so statements are never taken from a request.
  • AlterTableStatementAggregator folds a table’s changes into a single ALTER TABLE wherever the platform accepts a list of actions. MySQL and MariaDB already render one combined statement, PostgreSQL renders one per action and is folded afterwards, and SQLite accepts exactly one action per ALTER TABLE and cannot be folded at all.
  • ColumnDataMigration carries the two column changes that lose data without an accompanying statement: the EXT:indexed_search hash columns, which changed from an integer to a string and cannot be converted, so the table is emptied first; and the PostgreSQL auto increment column, which doctrine/dbal 4 implements as an identity column instead of as a serial, so the sequence is converted in place rather than dropped and recreated with a reset value.
  • Tables that exist as a view are skipped here as well – the same behaviour the backportable fix at stack position 4 adds to ConnectionMigrator, carried into DatabaseSchemaAnalyzer as part of this change. It needs no separate mention and resolves nothing on its own.
  • PackageSetup uses applySafe() and no longer computes the whole comparison twice just to apply it. DatabaseUpgradeWizardsService reads the detected operations instead of walking raw doctrine diffs, which is what SchemaMigrator::getSchemaDiffs() existed for – it had no other consumer and is removed.
  • The array shaped suggestion API keeps building its own comparison for now, together with the mutable diff copies it needs. Both go in sub-task 9.

The install tool

The module follows the same unit and is presented as a wizard: the groups are offered one at a time, and the schema is re-analyzed after every applied step, so the next step is built from what the previous one left rather than from the analysis the module started with. The steps are whatever the analysis returns; a step with nothing in it is neither shown nor counted.

  • One card per table. The headline states what happens to the table itself – add, modify, rename, drop – and that kind is decided server side, not reconstructed in the browser from an operation list. A destructive card carries an inline badge reading Destructive - read carefully next to the table name.
  • A tab strip per card, Changes and SQL, so nothing is a control that reveals something once and is then spent.
  • A detail table per kind of change below the headline – added fields, modified fields, added indexes, modified indexes, renamed fields, dropped fields, dropped indexes, changed table options – each shown only where there is something to show. A change shows both declarations, because knowing only the new one says nothing about whether the change is wanted. The second column is headed by what it actually holds: Type for fields, Definition for indexes, New name for a rename.
  • The statements are one block to copy out, terminated for the reader; the hash is built from the statements as the analysis produced them, so that terminator never reaches what is sent back. Copying reports inline next to the control that was used – a green Copied – instead of through a notification, which renders behind the modal backdrop and is gone before it can be read.
  • A permanent card at the end of each step shows all statements of the selected tables. What a step executed can be shown after it ran, off by default, since it is a review aid rather than part of getting through the wizard.
  • Operations carry their type next to their label, so the display no longer has to recognise English wording to know what it is showing. The mapping from an analysis to what is displayed moved into DatabaseAnalyzerSuggestionService, so the structure the JavaScript reads is covered by a test built from a real analysis.

The install tool part is deliberately a first iteration and is expected to change further as the remaining features and fixes of this series land. A full redesign of that module is on the table – either together with UX experts once the feature set has settled, or as part of the install tool modal rework. That has been discussed and is not decided yet, and it is explicitly not a reason to hold this change back.

ColumnDataMigration is prepared, the extension point is not decided

Both migrations are wired into the class directly for now, and the class is shaped for taking them out again rather than for keeping them:

  • it is a stateless service, process() takes a Dto\ColumnDataMigrationRequest and returns a Dto\ColumnDataMigrationResult,
  • the request already carries more than the two implementations read – the connection name next to the connection, and a ColumnDataMigrationStage naming which part of a change is being rendered,
  • every stage asks, including the ones nothing reacts to today: renaming and dropping whole tables go through the same seam. A stage nothing matches returns its statements unchanged, which is what makes each of them a place where something can be plugged in without moving the call,
  • todo markers sit where a dispatch would go.

Whether this becomes a PSR-14 event or an interface with registered migrations is explicitly open and not part of this series. The preparation is deliberately neutral between the two – both would receive exactly the request object that exists now – and nothing here should be read as a promise of either. The consumer builds the service with GeneralUtility::makeInstance() for the same reason: it has no dependency of its own yet, so there is nothing to inject, and the call site moves to constructor injection in the change that gives it one.

Everything in the analyzer stack is annotated internal@ and is not part of the public core API.

Patch

Gerrit 95192, topic database-analyzer.

Releases: main

Author Stefan Bürk
Assigned to Stefan Bürk
Created 08/11/26, 01:25
Updated 09/02/26, 13:16
Task
Under Review Stale Database API (Doctrine DBAL) TYPO3 CMS 15

#110426 Generate table option changes without platform hooks

doctrine/dbal neither compares nor applies table options such as ENGINE, ROW_FORMAT, the default character set or the collation. TYPO3 does, and injects the resulting statement by overriding getAlterTableSQL() on every extended MySQL and MariaDB platform. That override needs the extended TableDiff to read the changed options from, and is the last reason for the platform classes to know about a schema diff at all.

Fix

Since the statement depends on nothing but the platform, the current table and the changed options, it is built by TableOptionsStatementBuilder and added to the statements of the table like any other one. The MySQL rule to always re-apply ROW_FORMAT when ENGINE changes is kept, including the reasoning behind it: the row format stated at CREATE TABLE time is cached and would otherwise be re-applied by the engine change.

MySQLCompatibleAlterTablePlatformAwareTrait and the getAlterTableSQL() overrides of all eight MySQL and MariaDB platform classes are removed with it. None of them references a schema diff anymore, which is what lets the diff classes go in sub-task 9.

Patch

Gerrit 95191, topic database-analyzer.

Releases: main

Author Stefan Bürk
Assigned to Stefan Bürk
Created 08/11/26, 01:24
Updated 09/02/26, 13:16
Task
Under Review Stale Database API (Doctrine DBAL) TYPO3 CMS 15

#110425 Reduce column type comment handling to MySQL

With SQLite declaring dedicated JSON and UUID column types (sub-task 3), the doctrine type hint comment is only needed for a single type on a single platform family: neither MySQL nor MariaDB – including 11.7, which doctrine does not map to its native UUID type – offer a declaration that tells a GUID apart from any other CHAR(36). PostgreSQL never needed the comment, it has native json, jsonb and uuid types.

Fix

Keep the type comment where it is needed and remove TYPO3\CMS\Core\Database\Platform\PostgreSQLPlatform and PostgreSQL120Platform together with their entries in the driver middleware. Both only carried GetColumnDeclarationSQLCommentTypeAwareTrait and are empty without it, both are annotated internal@, and both were only ever instantiated there.

typeRequiresCommentHint() no longer needs its platform to type map either; the trait is used by the extended MySQL and MariaDB platforms only, so a plain type check is left and the reasoning why no other platform or type qualifies is documented in place.

Existing installations

Introspection keeps resolving an existing type comment on all platforms. Installations created before this still carry them, and the extended schema managers map those columns back to the same doctrine type. This is documented as Important, not as Breaking.

Supersedes the intent of Gerrit 93670.

Patch

Gerrit 95190, topic database-analyzer.

Releases: main

Author Stefan Bürk
Assigned to Stefan Bürk
Created 08/11/26, 01:24
Updated 09/02/26, 13:16
Feature
New Stale Logging

#110597 Add request object to TYPO3\CMS\Core\Log\Writer\AbstractWriter

It would be very helpful if a custom log writer had access to the current request object (e.g., to retrieve the request URL). Currently, this is only possible via $GLOBALS[‘TYPO3_REQUEST’].

Author Tee Ohh
Created 09/02/26, 10:02
Updated 09/02/26, 10:02
Task
Author Wouter Wolters
Assigned to Wouter Wolters
Created 08/13/26, 16:04
Updated 08/14/26, 21:10
Bug
Under Review Stale Image Cropping TYPO3 CMS 6.2

#58705 data-type-gettext-file inside FILES renderObj GIFBUILDER

Is it a normal behavior that data-type-gettext-file is not accessible inside the following structure?

uid:46 is a valid image file.

page >
page = PAGE

page.10 = FILES
page.10 {
  files = 46

  renderObj = IMAGE
  renderObj.file = GIFBUILDER
  renderObj.file.XY = 400,400
  renderObj.file.10 = IMAGE
  renderObj.file.10.file {
    import.data = file:current:publicUrl
    width = 400c
    height = 400c
  }
}

Save publicUrl to a register to access it later works:

page.20 = FILES
page.20 {
  files = 46

  renderObj = COA
  renderObj {
    1 = LOAD_REGISTER
    1.publicUrl.cObject = TEXT
    1.publicUrl.cObject.data = file:current:publicUrl

    10 = IMAGE
    10 {
      file = GIFBUILDER
      file {
        XY = 400,400

        10 = IMAGE
        10.file {
          import.data = REGISTER:publicUrl
          width = 400c
          height = 400c
        }
      }
    }
  }
}
Author Christian Stern
Created 05/12/14, 08:16
Updated 08/08/26, 22:44
Bug
Under Review Stale Themes TYPO3 CMS 14

#110388 Missing dependency for typo3/theme-camino

Camino uses typo3/cms-impexp but does not require this dependency in composer. If this package is not installed, typo3 extension:setup fails with a cryptic message:

[WARNING] theme_camino contains data to be imported, but the required component is not installed. Make sure to define corresponding requirements.                                                                                  
Author Dmitry Dulepov
Created 08/06/26, 20:23
Updated 08/08/26, 16:07
Feature
Under Review Stale

#110383 Site settings cache location

It should be possible to put site settings cache inside database, while the current file based solution stays the default. It’s relevant for cluster environments

Author Sven Liebert
Assigned to Sven Liebert
Created 08/06/26, 16:07
Updated 08/07/26, 15:14

Showing results 251 to 275 of 1561