DGS Bug Fix A list is not ordered by an isCustom field that the request or the session names; it takes defaultOrderField: StorePaginationTrait::getOrderByFieldName() accepted every field of the model, but an isCustom field has no column in the query, so a header link of such a field with sorting on, an order kept in the session after sorting was removed from it, or a hand-written URL put it into ORDER BY, and the database stopped the list with a "column does not exist" error. A field with a column is still accepted with or without sorting, and an order that the code of a project sets with setOrderByFieldName() is not checked, as before
DGS Bug Fix Applying the filters of a list replaces only the stored filters of that store: ListActionFieldTrait::_prepareFiltersFromRequest() emptied the whole DB_FILTERS session key, so a filter applied in one DGS, for example a block on a details page with its own ident, removed the filters of every other DGS, for example the main list of the same entity. The filters of the current store are still replaced by the set the request sends
DGS Bug Fix The filter of a foreignKey field queries the foreign rows of that field only, and only for a select or a multiple filter: ForeignKeyField::onFilterFetch() called Store::loadForeignKeys(), so a text filter on a users field read the whole users table on each page view, and every filter also read the rows of all other foreignKey fields of the store. A field with autocomplete or an ajax parent loads nothing, as loadForeignKeys() already skipped it. Store::loadForeignKeyValues() queries each field once for the store, and loadForeignKeys() goes through it, so a list with a fast-add row and a select filter queries the field one time; see "A foreignKey filter loads only its own options" in UPGRADE.md (BREAKING)
DGS Bug Fix The list query of a MySQL or PostgreSQL store ends its ORDER BY with the primary key, in the direction of the sort, and a store with no sort field orders by the primary key: rows with equal sort values had no fixed order, so PostgreSQL put them differently for each LIMIT and OFFSET, and a row appeared on two pages or on no page. MysqlProxy and PgsqlProxy take this order from the new SqlProxy::getOrderEndingWithPrimaryKey(); MssqlProxy and CassandraProxy keep their own order
Core Bug Fix Entity::fillString() gives no "Array to string conversion" warning for a row that holds an array, for example a many2many value: the placeholder of that column stays literal, as a scope placeholder with an array value does, where it became the text Array; the other columns of the row are filled as before.
Core Bug Fix On PHP 8.4 and 8.5, the CSV export, the CSV import, the list of a store on an OpenApi proxy and a combobox without a value give no deprecation: each CSV row is read and written through the new CsvFileImporter::readRow() and writeRow(), which give fgetcsv() and fputcsv() the enclosure and the escape character (CsvFileImporter::ENCLOSURE and ESCAPE, the values PHP used when they were not given), TextcomboboxField keys its list by an empty string for a null value, as PHP did, and StoreProxy declares protected mixed $session, which SqlProxy declared alone, so FiltersProxy no longer creates a dynamic property on an OpenApi proxy; the CI has the blocking job unit_and_integration_tests:mysql:php8.5, which fails on each deprecation of a Core file and lists each deprecation of a package in vendor/ once (see docs/CI.md); see "StoreProxy declares $session" in UPGRADE.md (BREAKING)
Core Fix Core::$db has the type ?IDataAccessObject, the type that DataAccessObject::factory() returns, in place of ?ObjectAdapter: Phan no longer reports $core->db = DataAccessObject::factory($pdo) of a project, and Core accepts a connection that is an IDataAccessObject but not an ObjectAdapter (for example a class that extends DataAccessObject), where PHP stopped with a TypeError; Core::OPTION_CONNECTION sets the same property, and a project that sets an ObjectAdapter keeps working without a change; a class that extends Core and declares $db again with ?ObjectAdapter is not loaded, and Phan reports a call of a method that only ObjectAdapter declares on $core->db; see "Core::$db takes an IDataAccessObject" in UPGRADE.md (BREAKING)
Core Feature Response::PARAM_CALLBACK_NAME (name) names the param of an ACTION_CALLBACK reply that holds the JavaScript function to call.
DGS Feature An action takes the attribute variant (IActionAttributes::OPTION_VARIANT, builder variant()), with the values of the enum ActionVariant: default, primary, success, info, warning and danger. Core sets it as a string on every action it prepares, read with ActionOptions::getVariant(): the remove action is danger by default, another action without a variant has null. See docs/DGS/Actions.md.
DGS Feature The Columns action takes the attributes disclaimer, hiddenColumnsLimit and hasResetToDefault (IActionAttributes::OPTION_*), read with ActionOptions::getDisclaimer(), getHiddenColumnsLimit() and hasResetToDefault(). ActionOptions::ATTRIBUTES names the prepared HTML attributes of an action link.
DGS Feature ListAction::SORTING_URL, SORTING_DIRECTION and SORTING_IS_CURRENT name the keys of the sorting of a list field, and Store::ORDER_ASCENDING and ORDER_DESCENDING name the two directions. See docs/DGS/Fields.md.
Core Bug Fix On PHP 8.5, Curl, ImageUtils, DownloadAction and the CSV import give no deprecation: they do not call curl_close(), imagedestroy() and finfo_close() any more. These functions have no effect since PHP 8.0 (curl_close(), imagedestroy()) and PHP 8.1 (finfo_close()), and PHP 8.5 deprecates them
DGS Bug Fix AbstractField::getType() takes the type of a field that has no type option from its class, for example checkbox for a CheckboxField: since the store fields declared strict_types, a field a project builds itself without set('type', ...) stopped the list of its store with a TypeError of getNormalizedType(); such a field now gets the queries, filters and CSS class of its type, where before strict_types it got an empty type and was read as a generic column; a class-name type with a namespace (for example Plugins\X\NoteField::class, or the class of such a field without a type option) collapses to its short type, note, where it kept the whole class name, which went into the CSS class of the field; a project field class that extends a framework field, with or without a namespace, takes the type of that field (each framework field class declares its type in the constant TYPE, and a project class inherits it or declares its own), for example checkbox for a ToggleField that extends CheckboxField, also through another project field class, so it gets the joins, filters, column names and inputs of the type without an override of getType(), and a class that extends AbstractField directly keeps its own short type; see "A project field class takes the type of the framework field it extends" in UPGRADE.md (BREAKING)
DGS Fix A filter on a field declared type="readonly" searches its own column instead of answering with an SQL error: ReadonlyField no longer overrides isVirtualField(), which the query proxies read as "no table column backs this field", so FiltersProxy::getDefaultColumnNameByFilter() returned null and emitted no WHERE while PgsqlProxy::getQueryHavingByFieldFilter() keyed the HAVING condition by the field's absent expression attribute, and because AbstractField::get() returns false for an attribute that is not there and $having[false] is $having[0], ObjectAdapter::getSqlCondition() passed the value through on its numeric-key branch and the query reached the database as FROM modules HAVING 36 - that key is PgsqlProxy's, where MysqlProxy inherits SqlProxy and keys by the field name and MssqlProxy keys by t.<name>, so the bare value is PostgreSQL's and the other two dialects are untested; the write protection now rests on isReadonly(), which RequestValuesPreparer::_isNeedPrepareFieldValue() asks in place of the raw readonly attribute so that the readonly type is covered and not only the attribute, and isReadonly() is declared on IStoreFieldState next to isVirtualField(), whose docblock no longer describes the other question; a field declared type="readonly" is shown on an insert and an edit form now, as a field carrying readonly="true" always was, and isEditable() reports it as editable, which routes its value to another table when the field also carries store=""; isEditable() itself is left as it was, because narrowing it would have stopped attribute-readonly fields routing and traded one regression for another; the HAVING branch keeps its numeric-key defect for its remaining occupants, a filtered type="sql" field and any field class of a project that overrides isVirtualField() without an expression attribute, for the range shape as well as for equality, where the same false concatenates away and gives HAVING BETWEEN 'a' AND 'b', none of which any test covers, while a filtered many2many field is not affected because SqlProxy lets it into the HAVING builder on its own branch and never reads expression; isReadonly() reads the attribute as a truthy value, the way the write path always read it, so readonly="1", readonly="yes" and readonly="on" keep protecting a field, and SelectField::fetchEditInput() and ForeignKeyField::fetchEditInput() ask isReadonly() instead of reading $this->attributes['readonly'] themselves, which leaves the predicate the only reader of that attribute in the package and changes one value: a select or foreign key written readonly="false" rendered a read-only preview, because the raw attribute is the non-empty string 'false', and renders an editable input now, matching the write path that always accepted its value; see "A readonly field has a column" in UPGRADE.md (BREAKING)
DGS Fix A request of a browser that names a row of a DGS with a parent relation is answered only for a row of the parent row the DGS was opened from, as its list is: Store::onRequest() examines the row once, before the action starts, when the model has a parent relation, the request names a row, the store is not in API mode and the action works on the row of the request (not a general action such as the list or an insert, not the CSV export or import, not a relation action), and it throws a PermissionsException (code 403) for a row whose relation column is not the parent value of the store (or is not NULL when the store has none) and for a row that does not exist, so the answer does not tell whether a row exists; the edit, info, remove, download, grid editor and custom actions and an action class of a project get the condition without a change of their own, where the edit form of such a row was shown, the edit was saved and the method of a custom action was called; a saved edit no longer takes the relation column from the form token, which moved the row to the parent row of the session, and an insert still takes it; the refusal is thrown in each mode of the store, so a download of such a row ends with the exception and not with status 404, and a store with no exception mode gets the exception and not an alert; the new Store::isRowOfParentValue() tells whether a loaded row is a row of the parent value and answers no for a row that was loaded without the relation column (the SQL proxies always load it; a child DGS on another proxy declares the column as a field); not changed are a DGS with no parent relation, the relation actions, the CSV import, Store::loadRowByPrimaryKey(), EditAction::load() and an action a page starts itself, every signature, and API mode, where each row is accepted as before; see "Row actions of a child DGS keep to the parent row" in UPGRADE.md (BREAKING)
Documentation Feature docs/DGS/Actions.md has the new section "Which Row an Action Accepts" with the condition of the parent row that Store::onRequest() examines, the refusal and the two ways a page of a project opens a row of a child DGS it chose itself; docs/DGS/README.md says that a child DGS works on the rows of its parent row, and docs/DGS/Api.md says that the edit, info and remove actions do not examine the row in API mode
Core Bug Fix A reply of Response has only the members that the caller set again, in the order in which the caller set them: since the commit of 2026-10-05 that gave Response::$type and Response::$_status a type and no default value, the ArrayObject kept the two values as items of the data, so each Response::JSON, JSON_P, JSON_IFRAME and JSON_JS reply had the members type (the response type, for example json) and _status (the HTTP status) before the members of the caller, a list such as a JSON-RPC batch was sent as an object, an empty reply was an object and not [], the action was no longer the last member, and a response whose data were replaced with exchangeArray() lost its type; the two properties have the default values Response::NORMAL and Response::STATUS_OK and the constructor sets them before it turns ARRAY_AS_PROPS on, so a subclass that declares them again without a default value gives the same reply
Core Bug Fix A plugin does not keep its PluginWrapper as an item of its ArrayObject: since the same commit, which gave AbstractPlugin::$plugin a type and no default value, each template of a DisplayPlugin of the Theme package got a variable $plugin that nobody assigned; $this->plugin of a plugin works as before
Documentation Fix docs/Core/Response.md, docs/DGS/CustomFields.md and docs/Frontend/React.md show a reply without the members type and _status and with the action as the last member, and no longer say that a response without an action has the type name in the key type
Documentation Fix docs/Core/Response.md no longer says to send a dialog made with $this->ui->dialog() with Response::ACTION_DIALOG, which puts a jQuery UI dialog around the finished Bootstrap modal and removes its footer buttons: such a dialog is sent with Response::ACTION_CONTENT, and ACTION_DIALOG is for a fragment with .e-caption and .e-buttons; the section "Local Development" of docs/Install.md describes the Docker files festi-install creates with --docker y (one docker/docker-compose.yml, started with docker compose up --build, the site on http://localhost:8000) instead of the files of the repository of the framework, whose Docker environment is described in CONTRIBUTING.md now
Core Fix A Response::JSON_P reply calls only a callback whose name is a JavaScript identifier: the name the request gives in its callback parameter has to be an identifier or several joined with a dot (letters, digits, _ and $, not starting with a digit, at most 128 characters), and any other value, among them an empty string, an array, alert(1);// and handlers[0], is refused with a SystemException before a header or any output is sent, where it used to be written into the script as it came, which let a link run any script on the site; the message does not repeat the refused value; a request without the parameter gets Jimbo.response, the function jimbo.js has, instead of Jimbo.responseIframe, which no package defines; the JSON of the reply keeps the new lines of a string as \n, where they used to be deleted, writes <, >, &, ' and " as \uXXXX, and a response that cannot be encoded gives a SystemException; the reply has the headers Content-Type: text/javascript; charset=utf-8 and X-Content-Type-Options: nosniff; the name and the body are the new JsonpCallbackName and JsonpBody of Festi\Core\Response; see "A JSON_P response checks the callback name" in UPGRADE.md (BREAKING)
Core Fix Template::fetch() includes the template file in a private method whose own names start with festiTemplate and never replaces a name that exists, so an assigned or local variable named templatePath no longer changes the file that is included and an assigned array named localVars is no longer turned into variables: these two, and vars, file, path and result, are ordinary template variables now, a variable named this is ignored where it stopped the fetch with an Error, a local variable still wins over an assigned one, and $this is still the template; a template no longer finds $templatePath, $file, $vars and $localVars of fetch() in its scope, so one that read them gets an undefined variable and uses __FILE, DIR and $this->getArrayCopy() instead, which no template of the framework or of the theme package does; StoreView and the fields extend Template and get the same; see "A template gets only its own variables" in UPGRADE.md (BREAKING)
DGS Feature StoreFieldEvent::EVENT_ON_GET_EDIT_VIEW is fired for a field of every type: getEditInput() of AbstractField is the one place that fires it, returns the content a listener set and otherwise calls the new protected fetchEditInput(mixed $value, ?array $row): ?string, which the sixteen field classes that overrode getEditInput() (TextField, TextareaField, SelectField, TextcomboboxField, ForeignKeyField, Many2manyField, CheckboxField, DatetimeField, FileField, MultiFileField, Md5Field, PriceField, PercentField, SerializeField, HandlerField and NumeratorField) override now, so the event reaches these and the five types that extend them, twenty-one types it never reached; the nine types that fired it already (autocomplete, composite, email, hidden, multiAutocomplete, number, password, readonly and sql) still give their listeners the escaped view value, through the new protected getEditInputValue(), and the other types give the value as it was passed; the event target has the record as row and StoreFieldEvent has getRow(); a field nobody listens to gives the same HTML as before; a field class of a project that overrides getEditInput() keeps working without the event, and UPGRADE.md says how to rename the override to fetchEditInput()
DGS Fix The view of a store looks for templates in the templates directory of the plugin of the store whenever the store gets its plugin, from its schema, from setPlugin() or as a PluginStore, through the new StoreView::addPluginTemplatePath(): the view read the plugin only while it was created, before the store had one, so the directory was added only for a store class that set its plugin in onPrepareOptions(), which still works and is no longer needed; the directory stays the last one the view looks in and is added once; AbstractPlugin::getPluginTemplatePath() returns null, for "no templates directory", instead of throwing SystemException('Unsupportable method.'), with the same signature, so a store of a plugin that is not a DisplayPlugin is created with no directory added, and code that caught that exception tests for null
Core Refactor The eighteen methods and two properties that kept a signature without a native type, because a class outside the repository overrides them without one, declare it now: onInit() of a plugin and install() of the system plugin return void, getResponseModel() takes two arrays and returns Response, onDisplayMain() takes string|false, string|false and array and returns ?bool, the system object declares getSettings(): array, getUrlRules(array $search): array and addUrlRule(array $values): mixed, DefaultUser declares get(string $name): mixed, set(string $name, mixed $value): mixed, getID(): mixed, getRole(): mixed, getSessionData(): array and array $requiredFields, ObjectPlugin declares ?IDataAccessObject $object, the fields declare getFilterTemplateName(): string, getInputType(): string, callHandlerMethod(array $params, string $methodPostfix): mixed and getCurrencySymbol(): string|false, IProxyRepository::insert() and IStore::getOption() return mixed, and PermissionsException sets its code 403 in a constructor with the parameters of SystemException instead of redeclaring $code; the tests/Resources/plugins/NonClassPlugin.php fixture declares strict_types; phpcs.xml.dist demotes no rule, so every finding of the coding standard, an error or a warning, fails the build; PHP does not load a plugin, package or project class that overrides one of these methods without the return type or redeclares one of the two properties without the type, and UPGRADE.md lists the members, the errors, a script that finds the overrides and adds the types, and what it reports per repository (BREAKING)
DGS Refactor ClassSchema declares the relations, listeners, routers, rules and external values of a schema in one section method, bindings(ISchemaBindings $bindings), whose argument returns the builder of each of the five sections, in place of the section methods relations(), listeners(), routers(), rules() and externalValues(), and takes the builders of its section methods from a new SchemaBuilders, both of Festi\Store\Schema\Builder, which clears the PHPMD coupling finding of ClassSchema (28 types, now 12), the last finding of the PHPMD ruleset in src. The other nine section methods, parent:: composition and the array build() returns do not change. build() refuses a schema class that still has a method with one of the five names with a SystemException that names the replacement; see "ClassSchema declares five sections in bindings()" in UPGRADE.md, which has a script that rewrites such classes (BREAKING)
DGS Refactor Store keeps the plugin it belongs to in its StoreComponents, as the public typed property $plugin, next to its model, view, proxy and rules manager, and StoreComponentsFactory creates the plugin, the initialised rules manager and the audit of a store, which clears the PHPMD coupling finding of Store (17 types, now 12): every public method of Store keeps its signature, among them getPlugin(), which still returns a reference, and setPlugin(), and the same store comes out with the same plugin, listeners, permission check and messages; the protected property $plugin of Store is gone, so a store class of a project reads and sets $this->components->plugin (or calls getPlugin()) instead of $this->plugin, and the protected method getRulesManager() is gone, so it reads $this->components->rulesManager and, to use a rules manager of its own, sets it in onInit() before parent::onInit(); a class that still uses or declares $plugin or getRulesManager() is stopped with an exception that names the replacement; StoreComponentsFactory::createRulesManager() takes the store, StoreIdentResolver::isSchemaClass() is public and StoreModel has getErrorMessage() and getPermissionSection(); see UPGRADE.md, which has a script that finds and rewrites the affected lines (BREAKING)
DGS Refactor AbstractAction builds its url through a new ActionUrlBuilder and handles an exception through a new ActionExceptionHandler, and InsertAction and RemoveAction report how the transaction of a record ended through a new TransactionOutcomeNotifier, all of core\store\action\helper, which clears the PHPMD coupling findings of AbstractAction (17 types, now 12) and InsertAction (15, now 12): getUrl(), doHandleException() and apply() keep their signatures, and the same urls, errors and events come out in the same order; the notifier takes over InsertAction::onCompleteTransaction(), addParentTransactionListeners() and $actionRecord, which no release had; AbstractAction::getStore() declares the return type Store, the class it always returned, instead of IStore, so an action class of a project that overrides getStore() with the return type IStore must declare Store; see UPGRADE.md (BREAKING)
DGS Refactor Store keeps the page and the order of its list (rowsPerPage, currentPage, totalRows, orderByFieldName and orderByDirection) in a StorePagination, held in the protected property $pagination, and its model, view, proxy and rules manager in a StoreComponents, held in the protected property $components, both of Festi\Store, instead of nine protected properties, which clears its PHPMD TooManyFields finding (17 fields, now 10); a new StoreComponentsFactory creates the four components, which takes the coupling of Store from 18 to 17 (that finding stays); a store class reads and sets the page and the order through $this->pagination and reads the components through getModel(), getView(), getProxy() and getRulesManager() or the public typed properties $model, $view, $proxy and $rulesManager of $this->components; every public method of Store, PluginStore and IStore keeps its signature and its result, getModel(), getView() and getProxy() still return a reference, and a clone still changes its page or replaces a component without the store it was made from; a store class that still uses or declares one of the nine names is stopped with a SystemException that names the replacement, on PHP 8.1, 8.2 and 8.3, where PHP alone would keep the write in a new property nothing reads; UPGRADE.md has the migration (BREAKING)
DGS Refactor StoreModel keeps the thirteen parts of a schema (fields, actions, relations, grouped, filters, sections, externalValues, routers, search, listeners, highlights, aggregations and rules) in a StoreSchemaParts of Festi\Store\Model, held in the protected property $parts, instead of thirteen protected array properties, which clears its PHPMD TooManyFields finding (20 fields, now 8): a model class reads a part with array access, $this->parts[StoreSchemaParts::FIELDS], which gives a reference, so that $this->parts[StoreSchemaParts::FIELDS][$name] = $field changes the part, and replaces it with $this->parts[StoreSchemaParts::FIELDS] = $fields; every public method of the model keeps its signature and the ones that return a reference still do, and each XML, array and class schema loads into the same model; a project model class that still reads, writes, tests or unsets $this->fields or another of the thirteen names, or declares such a property, is stopped with a SystemException that names the replacement, where PHP would have kept the value in an item of the ArrayObject without a message; for these checks the model no longer answers for properties as an ArrayObject with ARRAY_AS_PROPS does, so $store, $primaryKey and $_name are ordinary properties and no longer items of the model, and code outside a model that reads $model->primaryKey gets a SystemException where it got the key; UPGRADE.md has the migration (BREAKING)
Core Refactor The constructors of SystemException and FieldException take an ExceptionContext of Festi\Core\Exception, which holds the data or the label and the source, instead of the separate $data and $source parameters, which clears their two PHPMD ParameterCount findings: SystemException takes message, code, context, display message and previous exception, FieldException takes message, selector, code, context and previous exception and always shows its message unless setDisplayMessage() sets another one; calls with a message and a code, the named arguments previous and (for SystemException) displayMessage, the constructors of ApiException, StoreActionException and NotFoundException, and every getter are unchanged, an old call with a third positional argument (a fourth for FieldException) or with the named argument data or source fails with a TypeError or an Error and never runs with a changed meaning, NotFoundException now chains its $previous as the previous exception instead of storing it as the label, and UPGRADE.md has a script that finds the calls, the rule and an example for each old shape (BREAKING)
DGS Refactor Four protected proxy methods take value objects of Festi\Store\Proxy instead of five or six positional parameters, which clears their five PHPMD ParameterCount findings: updateForeignTableValues() and getDataForUpdateForeignTableValues() of the SQL proxies (and the MssqlProxy override) take a ForeignTableValues with the main table, the foreign table, the values of the foreign row and the current main row, updateForeignTableValues() still receives the values of the main row by reference after it and getDataForUpdateForeignTableValues() no longer takes them because the framework never read them, so the two methods no longer take the two value arrays in opposite orders; OpenApiProxy::loadRemoteListValues() and getListValuesEndpointUrl() take a ListValuesQuery with the columns, conditions, order, page and all-columns flag; the same values give the same queries, request url, result and exceptions, a project proxy that overrides one with the old parameters fails at class load and an old call fails with a TypeError, never with a changed meaning, and UPGRADE.md has the rule and an example for each method (BREAKING)
Core Refactor ImageUtils::setImageResize(), setImageResizeMagic() and createWatermark(), Curl::getUrl() and ApiUtils::send() take value objects of Festi\Core\Utils instead of five to seven positional parameters, which clears their five PHPMD ParameterCount findings: ImageSize, ImageOutput, Watermark and WatermarkColor for the images, CurlProxy for the proxy of a request, and ApiRequest for the data, method and headers of an API call, whose decoded body and response headers come back in an ApiResponse instead of a fifth by-reference parameter; the same values give the same file, cURL options, result and exceptions, an old call fails with a TypeError and never runs with a changed meaning, and UPGRADE.md has the rule and an example for each method (BREAKING)
Documentation Feature UPGRADE.md tells a developer or a coding agent what to change in a project for this release: a procedure with a class-load check that reports every project class PHP refuses to load, a table from error message to section, and one section per breaking change with the same four parts (what changed, who is affected, how to find it, what to do); AGENTS.md and CLAUDE.md ask every change that breaks project code to add its section in the same MR
Core Bug Fix FestiEvent::getType() returns the type of an event that was created with an integer type as a string again, as it did before src/event declared strict_types; it threw a TypeError, which broke every dispatch of festi-framework-async, whose event types are integers
Core Refactor ValuesObjectMapper declares strict_types and keeps handing the values to the setters of a project value object the way it did before: a setter such as setID(int $id) still receives the string id of a database row as an int, because the setter is called through the unqualified call_user_func(), which calls it in coercive mode (a fully qualified \call_user_func() or a use function import would make the call strict, and the new ValuesObjectMapperTest fails then), and the result of a filter callback is cast to bool
Core Bug Fix A plugin method reached through Core::call(), an event listener, a hook, a handler named in a store schema, a request rule and a log interceptor are called in coercive mode again, through the new Festi\Core\ProjectCallback: a route method that declares int $id receives 5 for the URL value '5', as it did before the framework files declared strict_types, instead of a TypeError; a value PHP cannot convert, such as a non-numeric string for int, is still refused
DGS Refactor SqlProxy builds the WHERE parts that come from the schema filters and the parent relation through a new SchemaFilterConditions, and collects and orders the joins of the routes through a new RouterJoins, which clears its PHPMD class complexity finding; getQueryWhere() and getQueryJoins() keep their signatures and return the same SQL
Core Refactor Entity reads a request value in the type of its field through a new RequestValueReader, which clears its PHPMD class complexity finding; getPreparedData(), getExtendData() and the constants are the same, and a subclass that redeclares a field type constant is still read by its own value
DGS Refactor StoreForm builds the config of a form through a new StoreFormConfigBuilder and its items and sections through a new StoreFormItems, which clears its PHPMD coupling finding; the constructor, fetch() and doPrefill() keep their signatures, and the form gets the same template variables and fires the same events in the same order
DGS Refactor XmlStoreModel reads the attributes and the text of schema elements through a new XmlAttributeReader, which clears its PHPMD class complexity finding; load() and the model it builds are the same as before
DGS Refactor InsertAction builds the values it saves through a new RequestValuesPreparer, which clears its PHPMD class complexity finding; getPreparedValues() keeps its signature and is called at the same point, and the same events are fired in the same order
Core Refactor Two locale classes each hand one private responsibility to a new class, clearing two PHPMD findings: MoDictionaryLocale keeps the header of a .mo file in a MoFileHeader value object instead of six fields, and PluralFormEvaluator reads its tokens through a PluralTokenStream; no public method changes, and every plural rule and .mo file gives the same result as before
DGS Refactor Three action classes that sat at a PHPMD limit each hand one private responsibility to a helper: RelationAction builds its redirect url through RelationRedirectUrlBuilder, ListAction renders its fast insert form through FastInsertForm, and CsvImportAction builds its upload form through CsvImportForm; no public or protected method changes, and each still runs where it ran before
DGS Refactor SqlForeignKeyProxy::loadForeignValues(), loadForeignAssigns() and loadForeignKeyValues() each move one block into a private method, which clears their three PHPMD NPathComplexity findings; the signatures, the SQL and the order of the queries are the same as before
Static Analysis Refactor Seven PHPMD findings in private methods are cleared without changing a public or protected signature: the XML store model loader passes an XmlAttributeQuery instead of six or seven parameters, SqlForeignKeyProxy passes ForeignAssignColumns, ImageUtils passes WatermarkText to its watermark drawing step, SqlProxy returns the router joins instead of filling a second by-reference array, and Core builds its default options from five named methods; the options, joins and SQL are the same as before
Static Analysis Refactor The remaining tests no longer pass an array literal as a call argument and write every array with several elements one element per line, so Festi.Functions.NoArrayArgument and Festi.Arrays.MultiLineArrayElements are errors on the whole tree again; each test asserts the same values as before
Static Analysis Refactor tests/Bundle/Store no longer passes an array literal as a call argument and writes every array with several elements one element per line; each test asserts the same values as before
Static Analysis Refactor src no longer passes an array literal as a call argument and writes every array with several elements one element per line (Festi.Functions.NoArrayArgument and Festi.Arrays.MultiLineArrayElements); the literal is built in a local variable before the call, with the same values and the same order; no behaviour changes
Static Analysis Refactor Every public method in src has a docblock that describes each parameter and the returned value (Logger, Core traits, events, locale, plugins and utilities in this change), so Festi.Commenting.PublicMethodDocBlock is an error on the whole tree again; no signature or behaviour changes
DGS Refactor Every public method left in src/store (the store traits, StoreAudit, the rules, the models and the schema builders) has a docblock that describes each parameter and the returned value; no signature or behaviour changes
DGS Refactor Every public method of src/store/view and of the IStore interface has a docblock that describes each parameter and the returned value; no signature or behaviour changes
DGS Refactor Every public method of src/store/event has a docblock that describes each parameter and the returned value; the listener interfaces say when the Store or an action calls them; no signature or behaviour changes
DGS Refactor Every public method of src/store/proxy has a docblock that describes each parameter and the returned value; no signature or behaviour changes
DGS Refactor Every public method of src/store/action has a docblock that describes each parameter and the returned value; no signature or behaviour changes
DGS Refactor Every public method of src/store/field has a docblock that describes each parameter and the returned value; no signature or behaviour changes
Core Feature A system plugin can tell which url rules a url matches without handling a request: ApiPlugin implements Festi\Core\Plugin\IUrlRuleFinder, whose findUrlRules($url, $areaIdent) returns the matching rules of the area as UrlRuleMatch objects in the order bindRequest() compares them, so the first one is the rule a request is routed by; bindRequest() takes its rule from the same Festi\Core\Plugin\UrlRuleMatcher, and its result is unchanged. The interface is separate from ISystemPlugin, so an existing system plugin keeps loading
Static Analysis Refactor With src and tests typed, phpcs.xml.dist demotes only what is left of the coding-standard 1.3.0 type rules: the native type of the members a class outside the repository overrides without one, and strict_types in two files; a parameter, return or property with no type at all, and an array that does not say what it holds, are errors on the whole tree again
Core Refactor src/util, src/exception, src/response, src/event and src/locale declare strict_types and native parameter, return and property types, with array shapes documented: a project class that overrides one of their methods, or redeclares one of their properties, must declare compatible types, and a caller must pass the declared types; this includes the option accessors of OptionsTrait (getOption(): mixed and getOptionByRef(): mixed, used by Core, AbstractPlugin, Store and AbstractAction), Permissions::doValidate(): void, and the event dispatcher, whose event type is a string (BREAKING)
Core Bug Fix Calls that relied on PHP coercing a scalar are cast explicitly, so they keep their result under strict_types: image sizes and watermark coordinates in ImageUtils, the date and client language helpers in FestiUtils, the display message and code of SystemException, and the .mo reader
Core Bug Fix Curl::getUrl() declares what it returns and accepts: false for an HTTP error, and a JSON string or null as the post data; SystemException::setDisplayMessage() accepts the false its own constructor passes
DGS Refactor Store, its traits, PluginStore, the store models, the rules, the store views and presenters, the store events and the schema builders declare strict_types and native parameter, return and property types, with array shapes documented: a project store or model that overrides one of their methods, or redeclares one of their properties, must declare compatible types; removeByPrimaryKey(), removeChildByPrimaryKey() and updateByPrimaryKey() take an int or string key, so a null key is refused before any child row is removed (BREAKING)
DGS Bug Fix Store code that relied on PHP coercing a scalar is cast explicitly, so it keeps its result under strict_types: the page size, page index and total count read from the request and the session, the order field and direction, the audit value names, the columns attribute of a form section, and the primary key a form config returns
DGS Refactor The field classes under src/store/field declare strict_types and native parameter, return and property types, with array shapes documented: a project field that overrides one of their methods must declare compatible types (getFormat(): string and getPreparedValueForEdit(): string among them; getFilterTemplateName(), getInputType(), HandlerField::callHandlerMethod() and PriceField::getCurrencySymbol() keep their signature for now, because known project fields override them without a type), and a model built from an array or a class must give string attributes as strings (BREAKING)
DGS Bug Fix Field code that relied on PHP coercing a scalar is cast explicitly, so it keeps its result under strict_types: a numeric string formatted as a price, a percent or a number, an int cell value escaped, trimmed or encrypted, the id Many2manyField passes to the proxy, the image sizes FileField reads from the resize attribute, and the timestamp TimestampField formats
DGS Refactor The store proxies under src/store/proxy declare strict_types and native parameter, return and property types, with array shapes documented: a project proxy that overrides one of their methods must declare compatible types, and updateByPrimaryKey() takes a string, int or bool key on the interface and every implementation (BREAKING)
DGS Bug Fix Proxy calls that relied on PHP coercing a scalar are cast explicitly, so they keep their result under strict_types: a scalar filter value read from the session (a list or an object there is refused with a StoreException that names the filter, as it was refused before, instead of filtering by the word Array), a primary key passed to the child stores, the row count PgsqlProxy reads from a result row, and the int that removeByPrimaryKey() returns
DGS Refactor The store actions under src/store/action declare strict_types and native parameter, return and property types, with array shapes documented: a project action that overrides one of their methods, or redeclares one of their properties, must declare compatible types (EditAction::load() and loadRow() return static), and a listener that receives the saved record, the list rows or the foreign key values by reference must leave an array there (BREAKING)
DGS Bug Fix Action code that relied on PHP coercing a scalar is cast explicitly, so it keeps its result under strict_types: the ids ForeignKeyLoadAction splits into a list, the file column and primary key DownloadAction reads, the cell values the grid editor and the list pass to the cell renderer, the current url and tree caption RelationAction works with, and a blank line in an imported CSV
DGS Bug Fix An action reports a database error whose code is a non-numeric SQLSTATE, such as 42S02, as its error: AbstractAction::doHandleException() turns any exception code into an int and the previous exception keeps the original, where the handler itself used to fail with a TypeError
Core Refactor Core, Entity, Response, DefaultUser, Logger, the Core traits, the plugin base classes and the system object declare strict_types and native parameter, return and property types, with array shapes documented: a project class that overrides one of their methods, or redeclares one of their properties, must declare compatible types (Response is the one projects usually extend), and a caller must pass the declared types; members that a known project or shared plugin overrides without a type keep their signature for now, among them DefaultUser::get(), getID(), getRole(), getSessionData(), set() and $requiredFields, and AbstractPlugin::onInit() (BREAKING)
Core Bug Fix Calls that relied on PHP coercing a scalar are cast explicitly, so they keep their result under strict_types: numeric array keys used as field names in Entity::getPreparedData() and getExtendData(), a scalar request value checked against a regexp or decoded as JSON, and the storage path prefix built from an id
Core Bug Fix ApiPlugin answers an exception with an HTTP status only when its code is one: an integer from 400 to 599 is used as the status, a code below 400 leaves the status as it is, and anything else, such as the SQLSTATE string of a PDOException or a code above 599, answers 500 instead of failing inside the exception handler
Tests Refactor Every file under tests/ declares strict_types and types its parameters, returns and properties, with the array shapes documented, as festi-team/coding-standard 1.3.0 asks; ids read back from the database are typed int|string, because the drivers return them as strings
Tests Refactor Every public and protected helper of FestiTestCase and TestUtils declares its parameter and return types: a project test class that overrides one must declare compatible types, the onTest*StoreAction() hooks and doTestStore() are void, except onTestInsertStoreAction(), which returns the Response, the two mock builders return a PHPUnit MockObject, and an argument of another type is refused in any file, strict or not (BREAKING)
Static Analysis Refactor festi-team/coding-standard is raised to ~1.3.0; its new type rules (parameter, return and property types, and declare(strict_types=1)) carry a backlog and report as warnings in phpcs.xml.dist until it is burned down, while every line a branch changes is still judged at full strength
Static Analysis Bug Fix SystemObject::isInstalled() quotes the table name it looks for through the connection instead of concatenating it into the query, which the standard's SQL injection plugin now reports
Core Refactor Response::send(), ArrayStoreModel::loadFromArray(), the list action's parent-relation redirect and TestUtils::installDatabase() are split into smaller steps so they stay within the standard's complexity limits; behaviour is unchanged
DGS Feature The default DGS URL prefix that a relation without a url redirects under is configurable through the dgs_default_url_prefix Core option (Core::OPTION_DGS_DEFAULT_URL_PREFIX, inherited by every store as Store::OPTION_DGS_DEFAULT_URL_PREFIX), instead of the hardcoded /festi/; the value is normalised to one leading and one trailing slash, an empty value means no page is a DGS page, and the default stays /festi/
DGS Bug Fix A list cell's containerCss is built once in ListAction::onStorageRowValue(), from the schema's containerCss and the field's row class (m-readonly), and no longer carries a trailing space, or a lone space when the field has neither; a project that overrides onStorageRowValue() without calling the parent now decides the readonly class too
DGS Bug Fix RemoveAction rolls the removal back whenever the action reports an error, also in custom-update mode (a listener set isUpdated): an error set by a listener or by the store's onRemoveHandler() used to be swallowed there and the removal committed. A custom update without an error, such as a soft delete after an integrity error, still commits
DGS Refactor The framework no longer logs DGS action failures: a failing Store::EVENT_ROLLBACK listener used to go to FestiUtils::doHandleCoreException() (the store log); now every exception an action handles, including transaction-event listener failures, is reported through Festi\Store\Event\ActionErrorEvent::EVENT_ON_ACTION_ERROR, and a project that wants those entries in its log must subscribe to it, e.g. from Core::EVENT_ON_CREATE_STORE (BREAKING)
DGS Feature ActionErrorEvent::EVENT_ON_ACTION_ERROR fires whenever an action handles an exception (AbstractAction::doHandleException()), with the action and the exception; a listener that throws is ignored so it never replaces the error it reports
DGS Feature Store::EVENT_COMMIT fires when the transaction that saved or removed a record is really committed, including a parent transaction's commit; a failing listener is handled like one of EVENT_AFTER_UPDATE: it becomes the action error and EVENT_AFTER_UPDATE listeners do not run, while the record stays saved
DGS Feature Store::EVENT_ROLLBACK fires when the transaction that saved or removed a record is really rolled back, whoever rolls it back; a failing listener never replaces the error that caused the rollback
DGS Refactor An action that owns its transaction fires Store::EVENT_COMMIT or Store::EVENT_ROLLBACK right after its own commit() or rollback() (TransactionOutcomeNotifier::notify()); one inside a parent transaction registers listeners on the connection and fires them when the parent ends (TransactionOutcomeNotifier::notifyWhenParentTransactionEnds(), using addCommitListener()/addRollbackListener() from festi-framework-database); the record travels as a Festi\Store\Event\ActionRecord value object; the rollback methods move out of AbstractAction, which brings it back under Sonar's method limit
DGS Bug Fix FileField and MultiFileField keep uploads consistent with the save: files written by a save that is rolled back are removed, a file an upload replaced is restored, and the backup is deleted on commit (Store\Field\Upload\TransactionalFiles; needs festi-framework-database with ITransactionListeners)
DGS Documentation The autocomplete branch of ForeignKeyLoadAction documents the application/json response and the flat results list of key and value pairs it answers with, and the response type it sets is covered by a test
DGS Refactor IStoreField::getElementName() returns a Festi\Store\Field\ElementName instead of a string, so the name a field publishes to the UI and the name a request carries back are read through one type that owns the encoding both ways; it is Stringable, so echo, concatenation, interpolation, sprintf, implode, preg_match and loose comparison keep working, while an array subscript raises a TypeError, a strict comparison against a string is false, json_encode writes an object and http_build_query drops the value - call getValue() at those sites (BREAKING)
DGS Bug Fix A field declared without a name is filed by an array store model under the position it publishes as its element name, instead of under the next free integer, so its autocomplete no longer loads the values of a different field or fails to find one at all
DGS Bug Fix A field or column whose own name begins with two underscores, such as the __ctx context token, is no longer mistaken for a positional element name by the foreign key load action or by the audit trail, which matched anywhere in the key and turned __ctx into the position 0
DGS Feature List rows are styled through Festi\Store\Event\ListRowStyleEvent: the row starts from its record class and the highlight classes its schema declares, and store listeners or a store implementing IListRowStyleListener add or remove classes for a record; the list and the grid editor share one IListRowStyleResolver, ListRowStyleResolver by default and replaceable per action with setListRowStyleResolver(), so rowCss keeps its value
DGS Refactor Action name to class resolution moves out of Store into Festi\Store\Action\StoreActionResolver, which answers null when no class backs an action name, so the display action trait and the list web presenter stop catching StoreException to ask the same question
DGS Refactor MssqlProxy assembles its row-count query with the core\dao\Query builder from the database package instead of concatenating SQL, so the dialect the connection speaks writes the statement
DGS Bug Fix PgsqlProxy selects its row count as __total_rows instead of total, so a store over a table that has a column of that name lists the column's own value rather than the number of rows on the page; the count still reaches the pager unchanged
DGS Refactor The row-count alias is a single SqlProxy::TOTAL_FIELD, and MssqlProxy names its row number from a constant too, so every proxy marks its internal columns the same __-prefixed way instead of TotalRecords and repeated literals
Plugin Refactor ISystemPlugin no longer declares setActiveMenu and getActiveMenu; a menu is a capability declared by Festi\Theme\UI\IMenuStructureProvider, which JimboPlugin already implements, so callers reaching these through an ISystemPlugin type hint should guard with instanceof IMenuStructureProvider first (BREAKING)
DGS Feature Session and global scope values can be used in row templates - action link, js and html, field autocomplete, composite format and the file path attributes - via S%key% and G%key%, read from $_SESSION and $GLOBALS the same way valuesWhere reads them; they are substituted after the row values so grid data cannot introduce a scope lookup the template does not already carry
Core Bug Fix Entity::fillString returns an empty string for a null template instead of raising a TypeError against its string return type
DGS Bug Fix Parent/child relation position is carried per browsing context in a __ctx token instead of a single shared session slot, so two browser tabs on the same table no longer overwrite each other's parent; every child/parent redirect url now carries that param, so code asserting on whole redirect urls must compare path and params separately
DGS Refactor ForeignKeyLoadAction returns JSON for dependent field loading instead of rendering a script template that the framework does not ship (BREAKING)
Static Analysis Refactor Coding standard and Phan baseline are consumed from the shared festi-team/coding-standard package; the vendored .phpcs directory and the duplicated Phan stubs and plugins are removed
Static Analysis Feature Code style is gated twice in CI: the whole tree against phpcs.xml.dist, and changed lines against the undemoted standard
Code Style Refactor Array syntax converted to the short form and wrapped boolean operators moved to trailing position across the tree
DGS Refactor Field cell trimming split into named steps and covered by tests
Plugin Refactor Data access objects are built through an injectable resolver
Api Refactor ApiPlugin settings and url rules split into composed traits
Core Feature Cache event bus added for project supplied cache backends
Api Enhancement Settings and url rules are served from the project cache when a cache listener is registered
Core Feature License files added to the project
Documentation Enhancement Documentation format guidelines section added
Plugin Enhancement Jimbo plugin method support updated
DateTime Bug Fix hasTime method now properly returns boolean true for time option
DateTime Refactor Datetime handling refactored with improved filter value processing
DateTime Enhancement Datetime range filter tests with inclusive end time support
Event Feature Event listeners can now be removed with improved documentation
Dependencies Feature ext-intl added as required dependency for internationalization
Docker Bug Fix Docker configuration and documentation corrected