Flow Command Reference
The commands in this reference are shown with their full command identifiers. On your system you can use shorter identifiers, whose availability depends on the commands available in total (to avoid overlap the shortest possible identifier is determined during runtime).
To see the shortest possible identifiers on your system as well as further commands that may be available, use:
./flow help
The following reference was automatically generated from code on 2024-06-11
Package NEOS.FLOW
neos.flow:cache:collectgarbage
Cache Garbage Collection
Runs the Garbage Collection (collectGarbage) method on all registered caches.
Though the method is defined in the BackendInterface, the implementation can differ and might not remove any data, depending on possibilities of the backend.
Options
--cache-identifierIf set, this command only applies to the given cache
neos.flow:cache:flush
Flush all caches
The flush command flushes all caches (including code caches) which have been registered with Flow’s Cache Manager. It will NOT remove any session data, unless you specifically configure the session caches to not be persistent.
If fatal errors caused by a package prevent the compile time bootstrap from running, the removal of any temporary data can be forced by specifying the option –force.
This command does not remove the precompiled data provided by frozen packages unless the –force option is used.
Options
--forceForce flushing of any temporary data
neos.flow:cache:flushone
Flushes a particular cache by its identifier
Given a cache identifier, this flushes just that one cache. To find the cache identifiers, you can use the configuration:show command with the type set to “Caches”.
Note that this does not have a force-flush option since it’s not meant to remove temporary code data, resulting into a broken state if code files lack.
Arguments
--identifierCache identifier to flush cache for
Related commands
neos.flow:cache:flushFlush all caches
neos.flow:configuration:showShow the active configuration settings
neos.flow:cache:list
List all configured caches and their status if available
This command will exit with a code 1 if at least one cache status contains errors or warnings This allows the command to be easily integrated in CI setups (the –quiet flag can be used to reduce verbosity)
Options
--quietIf set, this command only outputs errors & warnings
Related commands
neos.flow:cache:showDisplay details of a cache including a detailed status if available
neos.flow:cache:setup
Setup the given Cache if possible
Invokes the setup() method on the configured CacheBackend (if it implements the WithSetupInterface) which should setup and validate the backend (i.e. create required database tables, directories, …)
Arguments
--cache-identifier
Related commands
neos.flow:cache:listList all configured caches and their status if available
neos.flow:cache:setupallSetup all Caches
neos.flow:cache:setupall
Setup all Caches
Invokes the setup() method on all configured CacheBackend that implement the WithSetupInterface interface which should setup and validate the backend (i.e. create required database tables, directories, …)
This command will exit with a code 1 if at least one cache setup failed This allows the command to be easily integrated in CI setups (the –quiet flag can be used to reduce verbosity)
Options
--quietIf set, this command only outputs errors & warnings
Related commands
neos.flow:cache:setupSetup the given Cache if possible
neos.flow:cache:show
Display details of a cache including a detailed status if available
Arguments
--cache-identifieridentifier of the cache (for example “Flow_Core”)
Related commands
neos.flow:cache:listList all configured caches and their status if available
neos.flow:cache:warmup
Warm up caches
The warm up caches command initializes and fills – as far as possible – all registered caches to get a snappier response on the first following request. Apart from caches, other parts of the application may hook into this command and execute tasks which take further steps for preparing the app for the big rush.
Related commands
neos.flow:cache:flushFlush all caches
neos.flow:configuration:generateschema
Generate a schema for the given configuration or YAML file.
./flow configuration:generateschema –type Settings –path Neos.Flow.persistence
The schema will be output to standard output.
Options
--typeConfiguration type to create a schema for
--pathpath to the subconfiguration separated by “.” like “Neos.Flow
--yamlYAML file to create a schema for
neos.flow:configuration:listtypes
List registered configuration types
neos.flow:configuration:show
Show the active configuration settings
The command shows the configuration of the current context as it is used by Flow itself. You can specify the configuration type and path if you want to show parts of the configuration.
Display all settings: ./flow configuration:show
Display Flow persistence settings: ./flow configuration:show –path Neos.Flow.persistence
Display Flow Object Cache configuration ./flow configuration:show –type Caches –path Flow_Object_Classes
Options
--typeConfiguration type to show, defaults to Settings
--pathpath to subconfiguration separated by “.” like “Neos.Flow
neos.flow:configuration:validate
Validate the given configuration
Validate all configuration ./flow configuration:validate
Validate configuration at a certain subtype ./flow configuration:validate –type Settings –path Neos.Flow.persistence
You can retrieve the available configuration types with: ./flow configuration:listtypes
Options
--typeConfiguration type to validate
--pathpath to the subconfiguration separated by “.” like “Neos.Flow
--verboseif true, output more verbose information on the schema files which were used
neos.flow:core:migrate
Migrate source files as needed
This will apply pending code migrations defined in packages to the specified package.
For every migration that has been run, it will create a commit in the package. This allows for easy inspection, rollback and use of the fixed code. If the affected package contains local changes or is not part of a git repository, the migration will be skipped. With the –force flag this behavior can be changed, but changes will only be committed if the working copy was clean before applying the migration.
Arguments
--packageThe key of the package to migrate
Options
--statusShow the migration status, do not run migrations
--packages-pathIf set, use the given path as base when looking for packages
--versionIf set, execute only the migration with the given version (e.g. “20150119114100”)
--verboseIf set, notes and skipped migrations will be rendered
--forceBy default packages that are not under version control or contain local changes are skipped. With this flag set changes are applied anyways (changes are not committed if there are local changes though)
Related commands
neos.flow:doctrine:migrateMigrate the database schema
neos.flow:core:setfilepermissions
Adjust file permissions for CLI and web server access
This command adjusts the file permissions of the whole Flow application to the given command line user and webserver user / group.
Arguments
--commandline-userUser name of the command line user, for example “john
--webserver-userUser name of the webserver, for example “www-data
--webserver-groupGroup name of the webserver, for example “www-data
neos.flow:database:setcharset
Convert the database schema to use the given character set and collation (defaults to utf8mb4 and utf8mb4_unicode_ci).
This command can be used to convert the database configured in the Flow settings to the utf8mb4 character set and the utf8mb4_unicode_ci collation (by default, a custom collation can be given). It will only work when using the pdo_mysql driver.
Make a backup before using it, to be on the safe side. If you want to inspect the statements used for conversion, you can use the $output parameter to write them into a file. This file can be used to do the conversion manually.
For background information on this, see:
The main purpose of this is to fix setups that were created with Flow before version 5.0. In those cases, the tables will have a collation that does not match the default collation of later Flow versions, potentially leading to problems when creating foreign key constraints (among others, potentially).
If you have special needs regarding the charset and collation, you can override the defaults with different ones.
Note: This command is not a general purpose conversion tool. It will specifically not fix cases of actual utf8 stored in latin1 columns. For this a conversion to BLOB followed by a conversion to the proper type, charset and collation is needed instead.
Options
--character-setCharacter set, defaults to utf8mb4
--collationCollation to use, defaults to utf8mb4_unicode_ci
--outputA file to write SQL to, instead of executing it
--verboseIf set, the statements will be shown as they are executed
neos.flow:doctrine:create
Create the database schema
Creates a new database schema based on the current mapping information.
It expects the database to be empty, if tables that are to be created already exist, this will lead to errors.
Options
--outputA file to write SQL to, instead of executing it
Related commands
neos.flow:doctrine:updateUpdate the database schema
neos.flow:doctrine:migrateMigrate the database schema
neos.flow:doctrine:dql
Run arbitrary DQL and display results
Any DQL queries passed after the parameters will be executed, the results will be output:
doctrine:dql –limit 10 ‘SELECT a FROM NeosFlowSecurityAccount a’
Options
--depthHow many levels deep the result should be dumped
--hydration-modeOne of: object, array, scalar, single-scalar, simpleobject
--offsetOffset the result by this number
--limitLimit the result to this number
neos.flow:doctrine:entitystatus
Show the current status of entities and mappings
Shows basic information about which entities exist and possibly if their mapping information contains errors or not.
To run a full validation, use the validate command.
Options
--dump-mapping-dataIf set, the mapping data will be output
--entity-class-nameIf given, the mapping data for just this class will be output
Related commands
neos.flow:doctrine:validateValidate the class/table mappings
neos.flow:doctrine:migrate
Migrate the database schema
Adjusts the database structure by applying the pending migrations provided by currently active packages.
Options
--versionThe version to migrate to
--outputA file to write SQL to, instead of executing it
--dry-runWhether to do a dry run or not
--quietIf set, only the executed migration versions will be output, one per line
Related commands
neos.flow:doctrine:migrationstatusShow the current migration status
neos.flow:doctrine:migrationexecuteExecute a single migration
neos.flow:doctrine:migrationgenerateGenerate a new migration
neos.flow:doctrine:migrationversionMark/unmark migrations as migrated
neos.flow:doctrine:migrationexecute
Execute a single migration
Manually runs a single migration in the given direction.
Arguments
--versionThe migration to execute
Options
--directionWhether to execute the migration up (default) or down
--outputA file to write SQL to, instead of executing it
--dry-runWhether to do a dry run or not
Related commands
neos.flow:doctrine:migrateMigrate the database schema
neos.flow:doctrine:migrationstatusShow the current migration status
neos.flow:doctrine:migrationgenerateGenerate a new migration
neos.flow:doctrine:migrationversionMark/unmark migrations as migrated
neos.flow:doctrine:migrationgenerate
Generate a new migration
If $diffAgainstCurrent is true (the default), it generates a migration file with the diff between current DB structure and the found mapping metadata.
Otherwise an empty migration skeleton is generated.
Only includes tables/sequences matching the $filterExpression regexp when diffing models and existing schema. Include delimiters in the expression! The use of
–filter-expression ‘/^acme_com/’
would only create a migration touching tables starting with “acme_com”.
Note: A filter-expression will overrule any filter configured through the Neos.Flow.persistence.doctrine.migrations.ignoredTables setting
Options
--diff-against-currentWhether to base the migration on the current schema structure
--filter-expressionOnly include tables/sequences matching the filter expression regexp
--forceGenerate migrations even if there are migrations left to execute
Related commands
neos.flow:doctrine:migrateMigrate the database schema
neos.flow:doctrine:migrationstatusShow the current migration status
neos.flow:doctrine:migrationexecuteExecute a single migration
neos.flow:doctrine:migrationversionMark/unmark migrations as migrated
neos.flow:doctrine:migrationstatus
Show the current migration status
Displays the migration configuration as well as the number of available, executed and pending migrations.
Options
--show-migrationsOutput a list of all migrations and their status
Related commands
neos.flow:doctrine:migrateMigrate the database schema
neos.flow:doctrine:migrationexecuteExecute a single migration
neos.flow:doctrine:migrationgenerateGenerate a new migration
neos.flow:doctrine:migrationversionMark/unmark migrations as migrated
neos.flow:doctrine:migrationversion
Mark/unmark migrations as migrated
If all is given as version, all available migrations are marked as requested.
Arguments
--versionThe migration to execute
Options
--addThe migration to mark as migrated
--deleteThe migration to mark as not migrated
Related commands
neos.flow:doctrine:migrateMigrate the database schema
neos.flow:doctrine:migrationstatusShow the current migration status
neos.flow:doctrine:migrationexecuteExecute a single migration
neos.flow:doctrine:migrationgenerateGenerate a new migration
neos.flow:doctrine:update
Update the database schema
Updates the database schema without using existing migrations.
It will not drop foreign keys, sequences and tables, unless –unsafe-mode is set.
Options
--unsafe-modeIf set, foreign keys, sequences and tables can potentially be dropped.
--outputA file to write SQL to, instead of executing the update directly
Related commands
neos.flow:doctrine:createCreate the database schema
neos.flow:doctrine:migrateMigrate the database schema
neos.flow:doctrine:validate
Validate the class/table mappings
Checks if the current class model schema is valid. Any inconsistencies in the relations between models (for example caused by wrong or missing annotations) will be reported.
Note that this does not check the table structure in the database in any way.
Related commands
neos.flow:doctrine:entitystatusShow the current status of entities and mappings
neos.flow:help:help
Display help for a command
The help command displays help for a given command: ./flow help <commandIdentifier>
Options
--command-identifierIdentifier of a command for more details
neos.flow:middleware:list
Lists all configured middleware components in the order they will be executed
neos.flow:package:create
Create a new package
This command creates a new package which contains only the mandatory directories and files.
Arguments
--package-keyThe package key of the package to create
Options
--package-typeThe package type of the package to create
Related commands
neos.kickstarter:kickstart:packageKickstart a new package
neos.flow:package:freeze
Freeze a package
This function marks a package as frozen in order to improve performance in a development context. While a package is frozen, any modification of files within that package won’t be tracked and can lead to unexpected behavior.
File monitoring won’t consider the given package. Further more, reflection data for classes contained in the package is cached persistently and loaded directly on the first request after caches have been flushed. The precompiled reflection data is stored in the Configuration directory of the respective package.
By specifying all as a package key, all currently frozen packages are frozen (the default).
Options
--package-keyKey of the package to freeze
Related commands
neos.flow:package:unfreezeUnfreeze a package
neos.flow:package:refreezeRefreeze a package
neos.flow:package:list
List available packages
Lists all locally available packages. Displays the package key, version and package title.
Options
--loading-orderThe returned packages are ordered by their loading order.
neos.flow:package:refreeze
Refreeze a package
Refreezes a currently frozen package: all precompiled information is removed and file monitoring will consider the package exactly once, on the next request. After that request, the package remains frozen again, just with the updated data.
By specifying all as a package key, all currently frozen packages are refrozen (the default).
Options
--package-keyKey of the package to refreeze, or ‘all’
Related commands
neos.flow:package:freezeFreeze a package
neos.flow:cache:flushFlush all caches
neos.flow:package:rescan
Rescan package availability and recreates the PackageStates configuration.
neos.flow:package:unfreeze
Unfreeze a package
Unfreezes a previously frozen package. On the next request, this package will be considered again by the file monitoring and related services – if they are enabled in the current context.
By specifying all as a package key, all currently frozen packages are unfrozen (the default).
Options
--package-keyKey of the package to unfreeze, or ‘all’
Related commands
neos.flow:package:freezeFreeze a package
neos.flow:cache:flushFlush all caches
neos.flow:resource:clean
Clean up resource registry
This command checks the resource registry (that is the database tables) for orphaned resource objects which don’t seem to have any corresponding data anymore (for example: the file in Data/Persistent/Resources has been deleted without removing the related PersistentResource object).
If the Neos.Media package is active, this command will also detect any assets referring to broken resources and will remove the respective Asset object from the database when the broken resource is removed.
This command will ask you interactively what to do before deleting anything.
neos.flow:resource:copy
Copy resources
This command copies all resources from one collection to another storage identified by name. The target storage must be empty and must not be identical to the current storage of the collection.
This command merely copies the binary data from one storage to another, it does not change the related PersistentResource objects in the database in any way. Since the PersistentResource objects in the database refer to a collection name, you can use this command for migrating from one storage to another my configuring the new storage with the name of the old storage collection after the resources have been copied.
Arguments
--source-collectionThe name of the collection you want to copy the assets from
--target-collectionThe name of the collection you want to copy the assets to
Options
--publishIf enabled, the target collection will be published after the resources have been copied
neos.flow:resource:publish
Publish resources
This command publishes the resources of the given or - if none was specified, all - resource collections to their respective configured publishing targets.
Options
--collectionIf specified, only resources of this collection are published. Example: ‘persistent’
neos.flow:routing:list
List the known routes
This command displays a list of all currently registered routes.
neos.flow:routing:match
Match the given URI to a corresponding route
This command takes an incoming URI and displays the matched Route and the mapped routing values (if any):
./flow routing:match “/de” –parameters=”{"requestUriHost": "localhost"}”
Arguments
--uriThe incoming route, absolute or relative
Options
--methodThe HTTP method to simulate (default is ‘GET’)
--parametersRoute parameters as JSON string. Make sure to specify this option as described in the description in order to prevent parsing issues
neos.flow:routing:resolve
Build an URI for the given parameters
This command takes package, controller and action and displays the resolved URI and which route matched (if any):
./flow routing:resolve Some.Package –controller SomeController –additional-arguments=”{"some-argument": "some-value"}”
Arguments
--packagePackage key (according to “@package” route value)
Options
--controllerController name (according to “@controller” route value), default is ‘Standard’
--actionAction name (according to “@action” route value), default is ‘index’
--formatRequested Format name (according to “@format” route value), default is ‘html’
--subpackageSubPackage name (according to “@subpackage” route value)
--additional-argumentsAdditional route values as JSON string. Make sure to specify this option as described in the description in order to prevent parsing issues
--parametersRoute parameters as JSON string. Make sure to specify this option as described in the description in order to prevent parsing issues
--base-uriBase URI of the simulated request, default ist ‘http://localhost’
--force-absolute-uriWhether or not to force the creation of an absolute URI
neos.flow:routing:show
Show information for a route
This command displays the configuration of a route specified by index number.
Arguments
--indexThe index of the route as given by routing:list
neos.flow:schema:validate
Validate the given configurationfile againt a schema file
Options
--configuration-filepath to the validated configuration file
--schema-filepath to the schema file
--verboseif true, output more verbose information on the schema files which were used
neos.flow:security:describerole
Show details of a specified role
Arguments
--roleidentifier of the role to describe (for example “Neos.Flow:Everybody”)
neos.flow:security:generatekeypair
Generate a public/private key pair and add it to the RSAWalletService
Options
--used-for-passwordsIf the private key should be used for passwords
Related commands
neos.flow:security:importprivatekeyImport a private key
neos.flow:security:importprivatekey
Import a private key
Read a PEM formatted private key from stdin and import it into the RSAWalletService. The public key will be automatically extracted and stored together with the private key as a key pair.
You can generate the same fingerprint returned from this using these commands:
ssh-keygen -yf my-key.pem > my-key.pub ssh-keygen -lf my-key.pub
To create a private key to import using this method, you can use:
ssh-keygen -t rsa -f my-key ./flow security:importprivatekey < my-key
Again, the fingerprint can also be generated using:
ssh-keygen -lf my-key.pub
Options
--used-for-passwordsIf the private key should be used for passwords
Related commands
neos.flow:security:importpublickeyImport a public key
neos.flow:security:generatekeypairGenerate a public/private key pair and add it to the RSAWalletService
neos.flow:security:importpublickey
Import a public key
Read a PEM formatted public key from stdin and import it into the RSAWalletService.
Related commands
neos.flow:security:importprivatekeyImport a private key
neos.flow:security:listroles
List all configured roles
Options
--include-abstractSet this flag to include abstract roles
neos.flow:security:showeffectivepolicy
Shows a list of all defined privilege targets and the effective permissions
Arguments
--privilege-typeThe privilege type (“entity”, “method” or the FQN of a class implementing PrivilegeInterface)
Options
--rolesA comma separated list of role identifiers. Shows policy for an unauthenticated user when left empty.
neos.flow:security:showmethodsforprivilegetarget
Shows the methods represented by the given security privilege target
If the privilege target has parameters those can be specified separated by a colon for example “parameter1:value1” “parameter2:value2”. But be aware that this only works for parameters that have been specified in the policy
Arguments
--privilege-targetThe name of the privilegeTarget as stated in the policy
neos.flow:security:showunprotectedactions
Lists all public controller actions not covered by the active security policy
neos.flow:server:run
Run a standalone development server
Starts an embedded server, see http://php.net/manual/en/features.commandline.webserver.php Note: This requires PHP 5.4+
To change the context Flow will run in, you can set the FLOW_CONTEXT environment variable: export FLOW_CONTEXT=Development && ./flow server:run
Options
--hostThe host name or IP address for the server to listen on
--portThe server port to listen on
neos.flow:session:destroyall
Destroys all sessions.
This special command is needed, because sessions are kept in persistent storage and are not flushed with other caches by default.
This is functionally equivalent to ./flow flow:cache:flushOne Flow_Session_Storage && ./flow flow:cache:flushOne Flow_Session_MetaData
neos.flow:signal:listconnected
Lists all connected signals with their slots.
Options
--class-nameif specified, only signals matching the given fully qualified class name will be shown. Note: escape namespace separators or wrap the value in quotes, e.g. “–class-name Neos\Flow\Core\Bootstrap”.
--method-nameif specified, only signals matching the given method name will be shown. This is only useful in conjunction with the “–class-name” option.
neos.flow:typeconverter:list
Lists all currently active and registered type converters
All active converters are listed with ordered by priority and grouped by source type first and target type second.
Options
--sourceFilter by source
--targetFilter by target type