Browse documentation

#Upgrade Guide

This document provides guidelines for upgrading between versions of Flow PHP. Please follow the instructions for your specific version to ensure a smooth upgrade process.

#Upgrading from 0.42.x to 0.43.x

#1) flow-php/etl - to_transformation() expands a Transformation once per loader, not once per batch

Unchanged: any pipeline using ->collect(), drop(), select(), mask_columns(), batch_size(), batch_by().

#2) flow-php/telemetry - Tracer::span() no longer activates the span

Call sites relying on implicit nesting still compile and silently produce siblings. Rewrite each one that needs children:

Before:

$span = $tracer->span('parent');

try {
    // ...
} finally {
    $tracer->complete($span);
}

After:

$span = $tracer->span('parent');
$scope = $tracer->activate($span);

try {
    // ...
} finally {
    $scope->detach();
    $tracer->complete($span);
}

#3) flow-php/etl - window aggregates use the SQL default frame

On d = 2024-01-01, 2024-01-02, 2024-01-03, 2024-01-04 and s = 100, 200, 300, 400:

Restore the previous result:

sum(ref('s'))->over(window()->orderBy(ref('d'))->rowsBetween(unbounded_preceding(), unbounded_following()));

#4) flow-php/etl - count() over a window is SQL COUNT

On s = 100, 100, 300 ordered by a distinct column:

#5) flow-php/etl - partitionBy() no longer sets orderBy()

Add the ordering explicitly:

rank()->over(window()->partitionBy(ref('dept'))->orderBy(ref('salary')->desc()));

#6) flow-php/etl - WindowFunction::apply() receives a WindowContext

Implementations must no longer sort; $window->partition() and $window->frame() are already ordered.

#7) flow-php/postgresql - query recording moved to flow-php/symfony-postgresql-bundle

Applies to flow-php/postgresql users only through the bundle; Client\Telemetry is unchanged.

#Upgrading from 0.41.x to 0.42.x

#1) flow-php/symfony-telemetry-bundle - messenger tracing simplified

The worker-cycle span and the trace: worker/both modes are gone; a consumed message is a process span and a produced one a send span. The messenger:consume worker loop is suppressed via instrumentation.console.exclude_commands — which now fully suppresses matching commands (previously it only skipped the console span) and defaults to ['messenger:consume'] — so transport-poll/idle-tick work does not surface and the long-lived messenger:consume console span is dropped. Per-message handler traces are still recorded. Set console.exclude_commands: [] to trace the worker loop.

#2) flow-php/symfony-telemetry-bundle - cache span names unified to dotted lowercase

Cache spans now match the DBAL/messenger convention (dotted lowercase, low cardinality). The {key} and {pool} that were baked into the span name move out of it — they were already available as the cache.key and cache.pool attributes. Rename these series in dashboards and alerts, and update any filters on the camelCase cache.operation values.

#3) flow-php/telemetry - Sampler::shouldSample() receives the parent Context

Custom Sampler implementations (including a sampler: { type: service } service in flow-php/symfony-telemetry-bundle) must update the signature and forward $parentContext to any delegated sampler.

#4) flow-php/telemetry - ResettableContextStorage removed; MemoryContextStorage::reset() removed

The context storage is no longer tagged kernel.reset in flow-php/symfony-telemetry-bundle; scope balance is maintained by attach/detach alone. A custom context_storage service no longer needs a reset() method.

#5) flow-php/symfony-telemetry-bundle - messenger tracing middleware auto-injected into all buses

The tracing middleware is now injected into every message bus automatically. If you previously added flow.telemetry.messenger.middleware to a bus's framework.messenger.buses.*.middleware list by hand, remove it to avoid duplicate spans.

#6) flow-php/symfony-telemetry-bundle - http_kernel.exclude_paths now suppresses the whole request

An excluded path now attaches the OpenTelemetry suppression key for the request's duration (through kernel.terminate), so lower-level auto-instrumentation and terminate-phase database writes no longer emit orphan root spans (e.g. the /_wdt toolbar fetch writing an audit row after its response). If you relied on those child spans being recorded for an excluded path, remove the path from exclude_paths.

#7) flow-php/postgresql, flow-php/symfony-postgresql-bundle - traceTransactions bool replaced by

transactionSpans mode

TransactionSpanMode::PER_OPERATION emits a short span per BEGIN/COMMIT/ROLLBACK; GROUPED (default) keeps the single long-lived transaction span.

The db.client.operation.duration metric now uses only low-cardinality dimensions: queries are tagged with db.system.name, db.namespace, db.operation.name, db.collection.name; transactions with db.system.name, db.namespace, db.operation.name (begin/commit/rollback), db.transaction.nesting_level. db.query.text, db.query.parameter.*, server.address and db.transaction.savepoint are no longer metric dimensions.

#8) flow-php/symfony-telemetry-bundle - DBAL spans, metrics and config aligned with the PostgreSQL client

Query spans now carry db.system.name, db.namespace, server.address, server.port, db.operation.name, db.collection.name, db.response.returned_rows and (on error) db.response.status_code, and the instrumentation emits db.client.operation.duration and db.client.response.returned_rows metrics. If you matched DBAL spans by their doctrine.dbal.* names, switch to the semantic names above.

#9) flow-php/symfony-telemetry-bundle - custom attribute keys moved out of reserved OTel namespaces

#10) flow-php/symfony-telemetry-bundle - HTTP spans aligned with the stable HTTP semconv

Applies to the HttpKernel server span and to the http_client/psr18_client client spans.

#11) flow-php/symfony-telemetry-bundle - messenger destination is the transport; metrics_duration_unit removed

#12) flow-php/phpunit-telemetry-bridge - test.* keys aligned with the OTel test registry; durations in seconds

#13) flow-php/filesystem, flow-php/etl, flow-php/postgresql - flow-custom keys under flow.*; UCUM units

#14) flow-php/telemetry, flow-php/psr18-telemetry-bridge - shared semconv constants; UCUM time units

#15) flow-php/symfony-telemetry-bundle - runtime_mode removed; terminate flushes, process end shuts down

Drop the runtime_mode key from flow_telemetry config and remove any WorkerModeDetector service overrides.

#16) flow-php/telemetry - Telemetry::registerShutdownFunction() holds a weak reference

Keep the registered Telemetry instance referenced for as long as it should be shut down at process end.

#17) flow-php/etl - SchemaValidator::isValid() replaced by validate(): ValidationContext

Custom SchemaValidator implementations must return a Flow\ETL\Schema\Validator\ValidationContext built from the missing, mismatched (MismatchedDefinition), and unexpected definitions they reject.

#18) flow-php/filesystem - Partition name and value forbid { and }

{name} in a path is now a partition placeholder resolved from partitionBy() columns; strip braces from partition values before partitioning.

#19) flow-php/etl - Cache stores only Rows; cache indexes are stored as Rows

Custom Cache implementations must adopt the Rows-only signatures.

#20) flow-php/etl - cache and serialization use the Floe (.floe) binary format; datetime subclasses rejected

Delete cache directories written by 0.41 — the old serialized payloads are unreadable. Convert DateTime/DateTimeImmutable subclasses to DateTime/DateTimeImmutable before caching or serializing.

A Floe file carries exactly one schema, and sort / join / group-by spill batches through it — a pipeline with a drifting or schemaless source must declare column types at the source so nullable columns carry a concrete type (DataFrame::match($schema) validates but does not retype values):

->read(from_array($data, schema(str_schema('email'), float_schema('discount', nullable: true))))

#21) flow-php/symfony-telemetry-bundle - HttpKernelSpanSubscriber takes a

RouteNamePathMap instead of the router

Applies only to direct construction; services wired by the bundle need no change.

#22) flow-php/etl - sort algorithm is an explicit choice; external sort is the default

To sort in memory, opt in explicitly:

data_frame(config_builder()->sort(memory_sort()))->read(...)->sortBy(ref('id'))->run();

#23) flow-php/etl - joins emit every matching right row and follow SQL semantics

Rows::joinRight() emits matched rows in left-probe order and unmatched right rows last.

#24) flow-php/etl - join buckets storage is configurable, spills to disk by default

To keep the right side in memory and preserve left row order:

data_frame(config_builder()->join(hash_join()->storage(new MemoryBuckets())))
    ->read(...)
    ->join(...)
    ->run();

#25) flow-php/etl - Serializer works on Rows and filesystem streams

#26) flow-php/etl - EntryFactory API reshaped

#27) flow-php/etl - Encoder/Hydrator contracts; hydrator configured on the context

cast() coerces untrusted values through the schema (null schema infers types); hydrate() instantiates trusted, already-typed values and requires a schema. A custom extractor reading raw values (CSV, JSON, XML, Excel, Text, Google Sheet, PostgreSQL, Doctrine) calls $context->hydrator()->cast(...); a self-describing source (Parquet, Floe) calls $context->hydrator()->hydrate(...).

Under a schema, entries emit in schema-definition order (was data-key order with missing columns appended); a schema column missing from the source hydrates as a typed null (was a StringEntry null); a column absent from the schema is dropped. When the flow_php extension is loaded, AdaptiveRowHydrator runs hydration natively — pin the pure-PHP engine with config_builder()->hydrator(new PhpRowHydrator()).

#28) flow-php/etl-adapter-csv, -json, -parquet, -xml, -excel, -doctrine, -postgresql, -seal, -text,

-google-sheet - per-format Encoders replace normalizers

Behavioural changes: CSV/JSON/XML/Excel/Seal date columns render with dateFormat (Y-m-d, was dateTimeFormat); XML date/time columns render (was InvalidArgumentException); Seal time columns render as microseconds (was null); Google Sheet _spread_sheet_id/_sheet_name are appended to the schema under putInputIntoRows() (were dropped when a schema was set); Excel now appends _input_file_uri under putInputIntoRows().

#29) flow-php/etl - null is a first-class NullEntry/NullDefinition; from_null metadata removed

#30) flow-php/etl - group by runs on bucketing storage; only referenced columns are spilled

Custom aggregators must implement references() - return the references the aggregator reads, or null when they cannot be statically enumerated (disables spill column pruning).

#31) flow-php/etl - DataFrame::pivot() removed; pivot is declared between groupBy() and aggregate()

#32) flow-php/etl-adapter-csv, -excel, -json,

-xml - explicit schema no longer projects partition columns away

Declare the partition column in the schema to control its type.

#33) flow-php/etl - Schema and Schema\Definition mutators return a new instance

Assign the result of every Schema mutator - add, addAfter, addBefore, addMetadata, gracefulRemove, insertAt, keep, makeNullable, merge, moveAfter, moveBefore, moveTo, prepend, remove, rename, reorder, replace, setMetadata, sort - and of Definition::addMetadata() / Definition::setMetadata(). Discarding it is a silent no-op.

#Upgrading from 0.40.x to 0.41.x

#1) Removal of Elasticsearch Adapter

The Elasticsearch adapter has been removed from Flow PHP and replaced by the SEAL adapter (flow-php/etl-adapter-seal), a search engine abstraction layer that supports Elasticsearch, OpenSearch, Meilisearch, Solr, Typesense, Algolia, RediSearch and Loupe.

To migrate, install the SEAL adapter together with the engine adapter for your backend:

composer require flow-php/etl-adapter-seal cmsig/seal-elasticsearch-adapter

Then build a CmsIg\Seal\Engine and pass it to to_seal_upsert() instead of the previous to_es_bulk_index() (or Meilisearch) DSL functions:

use CmsIg\Seal\Engine;
use CmsIg\Seal\Adapter\Elasticsearch\ElasticsearchAdapter;

use function Flow\ETL\Adapter\Seal\to_seal_upsert;

$engine = new Engine(
    new ElasticsearchAdapter($client),
    $schema,
);

data_frame()
    ->read(/* ... */)
    ->write(to_seal_upsert($engine, 'index_name'))
    ->run();

#2) flow-php/symfony-telemetry-bundle -

flow-php/symfony-http-foundation-telemetry-bridge is now an optional dependency

instrumentation.http_kernel.context_propagation is silently disabled when the bridge is absent. To keep extracting incoming and injecting outgoing W3C trace headers:

composer require flow-php/symfony-http-foundation-telemetry-bridge

#3) flow-php/telemetry - trace id derived from the active span; root spans start a new trace

Context no longer stores a standalone trace id; attach the active span as a SpanContext to keep subsequent spans in the same trace.

#4) flow-php/symfony-telemetry-bundle - each consumed Messenger message is its own trace

#5) flow-php/telemetry-otlp-bridge, flow-php/symfony-telemetry-bundle - curl is synchronous; async moved to

async_curl

#6) flow-php/symfony-postgresql-bundle - migrations run against a single configured connection

To run migrations against a non-default connection, set migrations.connection instead of passing -c:

flow_postgresql:
  migrations:
    enabled: true
    connection: analytics

#7) flow-php/symfony-telemetry-bundle - static resource cache file is keyed by kernel environment

Delete the orphaned flow_telemetry_resource.cache from the temp dir; a per-env file is written on the next run.

#8) flow-php/symfony-telemetry-bundle - messenger worker receive cycle is traced; link_to_worker config removed

Remove the link_to_worker key from config. Idle passes (no message received) are marked messaging.symfony.worker.idle: true.

#9) flow-php/symfony-telemetry-bundle - messenger instrumentation also emits messaging metrics

Disable with instrumentation.messenger.metrics: false; set the messaging.process.duration unit via instrumentation.messenger.metrics_duration_unit (s default, or ms).

#10) flow-php/etl, flow-php/filesystem, flow-php/postgresql, flow-php/symfony-telemetry-bundle,

flow-php/phpunit-telemetry-bridge - emitted metric names standardized

Rename these series in dashboards and alerts.

#11) flow-php/symfony-telemetry-bundle - messenger trace/link config; propagation_style removed

Remove propagation_style from config — continue mode is gone (it made the consumer span absorb the queue wait time). trace selects which spans are emitted (handlers = the process/send message spans; none = metrics only); link selects the consumer span's links. link: worker/both requires trace to include the worker, otherwise the config is rejected. When trace excludes the worker, the transport's poll instrumentation (Doctrine DBAL, HTTP client, …) is suppressed during the receive loop so it does not surface as orphan spans — no messenger.receive span, no orphans either way.

#Upgrading from 0.39.x to 0.40.x

#1) flow-php/postgresql - column and domain defaults are modeled as ColumnDefault

Column::create() / Domain::create() still accept bool|float|int|string|Expression|null. Schema arrays serialized by Column::normalize() / Domain::normalize() before 0.40 must be regenerated — fromArray() reads the nested default shape only.

#2) flow-php/telemetry - Log severity filtering moved to a pipeline middleware

The previously wrapped processor is now the pipeline's sink and must implement Flow\Telemetry\Logger\LogSink (the built-in batching, pass_through, memory, void and composite log processors already do).

Before:

$processor = severity_filtering_log_processor(
    batching_log_processor($exporter),
    Severity::WARN,
);

After:

$processor = pipeline_log_processor(
    [severity_filtering_log_middleware(Severity::WARN)],
    batching_log_processor($exporter),
);

#2) flow-php/symfony-telemetry-bundle - severity_filtering log processor type replaced by pipeline

The severity_filtering processor type (with its inner_processor) is no longer a logger_provider processor type; it is a middleware inside a pipeline.

Before:

flow_telemetry:
  logger_provider:
    processor:
      type: severity_filtering
      minimum_severity: warn
      inner_processor:
        type: batching
        exporter: otlp

After:

flow_telemetry:
  logger_provider:
    processor:
      type: pipeline
      middleware:
        - { type: severity_filtering, minimum_severity: warn }
      sink:
        type: batching
        exporter: otlp

#3) flow-php/symfony-telemetry-bundle - named scope attributes split into scope and signal

Applies to tracers, meters, and loggers. The attributes map is no longer a flat list of scope attributes; scope attributes move under attributes.scope.

Before:

flow_telemetry:
  loggers:
    audit:
      attributes:
        team: checkout

After:

flow_telemetry:
  loggers:
    audit:
      attributes:
        scope:
          team: checkout

#4) flow-php/postgresql - DateTimeConverter split into TimestampConverter and TimestampTzConverter

#5) flow-php/etl-adapter-postgresql - DateTimeEntry maps to timestamp instead of timestamptz

To keep the previous behavior, pass overrides to EntryTypesMap:

to_pgsql_table($client, 'users')->withTypesMap(new EntryTypesMap(
    [DateTimeEntry::class => ValueType::TIMESTAMPTZ],
    [DateTimeType::class => ColumnType::timestamptz()],
));

#6) flow-php/symfony-postgresql-messenger - messenger_messages time columns use timestamp instead of

timestamptz

Existing tables, realign the column type (UTC instants preserved):

ALTER TABLE messenger_messages
    ALTER COLUMN created_at TYPE TIMESTAMP USING created_at AT TIME ZONE 'UTC',
    ALTER COLUMN available_at TYPE TIMESTAMP USING available_at AT TIME ZONE 'UTC',
    ALTER COLUMN delivered_at TYPE TIMESTAMP USING delivered_at AT TIME ZONE 'UTC';

#7) flow-php/telemetry - OTEL_RESOURCE_ATTRIBUTES keys and values are percent-decoded, not backslash-escaped

Re-encode any OTEL_RESOURCE_ATTRIBUTES that relied on backslash escaping; both keys and values are now percent-decoded.

#Upgrading from 0.37.x to 0.38.x

#1) flow-php/types - PHPStan extension extracted to flow-php/phpstan-types-bridge

The StructureTypeReturnTypeExtension — which narrows the return type of type_structure() for PHPStan — has been moved out of flow-php/types into a dedicated package, flow-php/phpstan-types-bridge. flow-php/types no longer ships any PHPStan code.

If you used type_structure() together with PHPStan, install the new package:

composer require --dev flow-php/phpstan-types-bridge

With phpstan/extension-installer the extension is registered automatically. If you registered it manually, update your phpstan.neon:

Before:

services:
    -
        class: Flow\Types\PHPStan\StructureTypeReturnTypeExtension
        tags:
            - phpstan.broker.dynamicFunctionReturnTypeExtension

After:

includes:
    - vendor/flow-php/phpstan-types-bridge/extension.neon

#Upgrading from 0.36.x to 0.37.x

#1) flow-php/telemetry - Per-signal exporter contracts merged into Exporter

#2) flow-php/telemetry - Transport contract relocated to OTLP bridge

#3) flow-php/telemetry - Processor interfaces

Applies to SpanProcessor, MetricProcessor, LogProcessor.

#4) flow-php/telemetry - Serializer contract removed

#5) flow-php/telemetry - ErrorHandler contract added

New namespace Flow\Telemetry\ErrorHandler with: ErrorHandler (interface), ErrorLogHandler, NullErrorHandler, StreamHandler, SyslogHandler, UdpSyslogHandler, CompositeErrorHandler.

#6) flow-php/telemetry-otlp-bridge - HttpTransport removed

#7) flow-php/telemetry-otlp-bridge - Per-signal OTLP exporters merged

#8) flow-php/telemetry-otlp-bridge - Curl/gRPC timeouts switched to milliseconds

#9) flow-php/telemetry-otlp-bridge - StreamTransport added

New transport, no removal counterpart.

#10) flow-php/telemetry-otlp-bridge - open-telemetry/gen-otlp-protobuf dependency dropped

#11) flow-php/symfony-telemetry-bundle - Configuration schema rewrite

No BC shim. Configurations from 0.36 must be rewritten.

Before:

flow_telemetry:
  exporters:
    otlp:
      type: otlp
      transport:
        type: curl
        endpoint: 'http://otel-collector:4318'
        timeout: 30
        connect_timeout: 10
    custom: { type: service, service_id: 'app.x' }
    debug: { type: console }

  tracer_provider:
    processor:
      type: batching
      exporter: { type: otlp, transport: { type: curl, endpoint: 'http://otel-collector:4318' } }

After:

flow_telemetry:
  error_handlers:
    default: { type: error_log }

  exporters:
    otlp:
      otlp:
        transport:
          type: curl
          endpoint: 'http://otel-collector:4318'
          timeout_ms: 250
          connect_timeout_ms: 250
    custom: { service: { id: 'app.x' } }
    debug: { console: ~ }

  tracer_provider:
    processor:
      type: batching
      exporter: otlp

#12) flow-php/phpunit-telemetry-bridge - Configuration parameters

otel_collector_url / FLOW_PHPUNIT_OTEL_COLLECTOR_URL remain deprecated aliases for endpoint with transport=curl.

#Upgrading from 0.35.x to 0.36.x

#1) flow-php/postgresql - RawCondition and RawExpression removed

The raw_cond() and raw_expr() escape hatches have been removed. All query builder operations are now covered by type-safe DSL functions.

#2) flow-php/postgresql - Condition now extends Expression

Conditions are now expressions — they can be used in SELECT lists, CASE WHEN, ORDER BY, etc.

// Conditions can now be aliased and used as expressions:
select(eq(col('a'), col('b'))->as('is_equal'));

// NOT works in both WHERE and SELECT:
not_(col('is_deleted'))->as('is_active');

// CASE WHEN accepts conditions directly:
case_when([when(eq(col('x'), literal(0)), literal('zero'))]);

#3) flow-php/postgresql - DSL condition function renames

Function names have been unified following standard SQL builder conventions (jOOQ, Diesel, SQLAlchemy).

New functions added:

Before:

use function Flow\PostgreSql\DSL\{cond_and, cond_not, cond_true, neq, lte, gte, is_in, any_sub_select};

select(col('name'))
    ->where(cond_and(
        neq(col('status'), literal('deleted')),
        lte(col('age'), literal(65)),
        gte(col('age'), literal(18)),
        is_in(col('role'), [literal('admin'), literal('user')]),
    ));

After:

use function Flow\PostgreSql\DSL\{and_, ne, le, ge, in_};

select(col('name'))
    ->where(and_(
        ne(col('status'), literal('deleted')),
        le(col('age'), literal(65)),
        ge(col('age'), literal(18)),
        in_(col('role'), [literal('admin'), literal('user')]),
    ));

#4) flow-php/postgresql - Schema builder methods accept Expression/Condition instead of strings

Methods that previously accepted raw SQL strings now require typed Expression or Condition objects.

#5) flow-php/postgresql - DSL functions split into separate files

The monolithic functions.php has been split into 5 focused files (same namespace, no import changes needed):

#6) flow-php/filesystem - Protocol and Backend removed, Mount rewritten

The filesystem library has been redesigned around a single mount-protocol string. The Protocol and Backend value types are gone; Mount now wraps just a protocol name.

Protocol class removed. Path::protocol() now returns string instead of a Protocol object. Callsites that unpacked Protocol::$name / Protocol::scheme() / Protocol::is() are mechanical updates:

Backend enum removed. There's no closed set of backends anymore — any filesystem can mount under any protocol. The Symfony bundle schema now uses a plain string type: field (see below). If you branched on Backend cases in application code, replace with string comparisons against the factory type() or the mount protocol, whichever fits.

Mount rewritten. The shape is now:

final readonly class Mount
{
    public string $protocol;

    public function __construct(string $protocol); // validates against PROTOCOL_REGEX
    public function supports(Path|string $path) : bool;
}

Filesystem::protocol() renamed to Filesystem::mount(). The return type changed from Protocol to Mount. Every Filesystem implementation must rename the method.

Filesystem ctors take Mount directly. NativeLocalFilesystem, MemoryFilesystem, StdOutFilesystem, AsyncAWSS3Filesystem, AzureBlobFilesystem now accept Mount as the first constructor argument (local filesystems have a sensible default). DSL factory functions (native_local_filesystem, memory_filesystem, stdout_filesystem, aws_s3_filesystem, azure_filesystem) accept string $protocol as the last argument with a sensible default ('file', 'memory', 'stdout', 'aws-s3', 'azure-blob') and build the Mount internally — no caller change needed unless you instantiate the filesystem class directly or mount two filesystems of the same backend under distinct protocols.

Auto-alias dropped. Previously, mounting a single filesystem of a given backend would auto-register its canonical scheme as an additional alias (e.g. mounting S3 as warehouse also made aws-s3 available). That behavior is gone — every mount is registered under exactly the protocol you pick. If you need two protocols for the same filesystem, mount it twice explicitly.

FilesystemTable::for(Path|Protocol) → for(Path|string). Pass a Path or a plain protocol string.

#7) flow-php/filesystem - NativeLocalFilesystem::list() no longer sorts results

Glob::glob() was replaced with lazy Webmozart\Glob\Iterator\GlobIterator to avoid materializing the entire matching set up front (this gives a ~30× speedup on large trees when the caller only needs the first N entries).

Side effect: NativeLocalFilesystem::list() no longer returns results in alphabetical order. Output now follows filesystem traversal order. If your code depends on sort order, sort client-side after consuming the generator:

$statuses = iterator_to_array($fs->list(path('/some/dir/**/*.txt')));
usort($statuses, static fn (FileStatus $a, FileStatus $b) => $a->path->uri() <=> $b->path->uri());

#8) flow-php/symfony-filesystem-bundle - YAML schema now uses type: + protocol-as-key

The configuration schema changed significantly. The YAML key under filesystems: is now the mount protocol (any valid URI scheme), and a separate type: field picks the factory.

Before:

flow_filesystem:
  fstabs:
    default:
      filesystems:
        file: ~
        memory: ~
        aws-s3:
          bucket: '%env(S3_BUCKET)%'

After:

flow_filesystem:
  fstabs:
    default:
      filesystems:
        file:
          type: file
        memory:
          type: memory
        aws-s3: # mount protocol — can be any valid URI scheme
          type: aws_s3               # factory lookup key
          bucket: '%env(S3_BUCKET)%'

Benefits of the new shape:

• Mount the same backend twice under different protocols (e.g. warehouse + archive both type: aws_s3 with different buckets).
• Protocol names are no longer tied to factory names — pick whatever reads well in your application.

Built-in type values: file, memory, stdout, aws_s3, azure_blob.

#9) flow-php/symfony-filesystem-bundle - FilesystemFactory interface and attribute changed

// Before
interface FilesystemFactory
{
    public function protocol() : Protocol;
    public function create(string $mountName, array $config) : Filesystem;
}

#[AsFilesystemFactory(protocol: 'my-fs')]

// After
interface FilesystemFactory
{
    public function type() : string;
    public function create(string $protocol, array $config) : Filesystem;
}

#[AsFilesystemFactory(type: 'my_backend')]

The DI tag attribute is renamed from protocol to type. FilesystemFactoryRegistry::get() takes a string $type instead of a Backend.

#10) flow-php/symfony-filesystem-bundle - flow:filesystem:ls CLI flags reshuffled

Default behavior: list all entries, paginated in tables of 10 rows; interactive terminals prompt between pages (Enter continues, "no" stops), piped output flows continuously. Size is formatted with binary units, Modified as ISO-8601 — both read from the backend listing response, no per-file HEAD.

#11) flow-php/symfony-filesystem-bundle - flow:filesystem:stat rejects pattern paths

stat now returns Command::FAILURE with a clear error when given a pattern path (memory://*.txt, **/*.parquet, …). Previously it returned metadata for the first match — confusing semantics. Use flow:filesystem:ls for pattern inspection.

#12) flow-php/filesystem-async-aws-bridge,

flow-php/filesystem-azure-bridge - DSL protocol is the last argument with a default

The DSL factories expose the mount protocol as an optional last argument, defaulted to the conventional scheme. Common cases work without passing it:

aws_s3_filesystem($bucket, $client);                              // mounts under 'aws-s3'
azure_filesystem($blobService);                                   // mounts under 'azure-blob'

// Pick a different protocol — e.g. mount the same bucket twice
aws_s3_filesystem($bucket, $client, protocol: 'warehouse');
azure_filesystem($blobService, protocol: 'archive');

#13) flow-php/filesystem - path_memory() and path_stdout() DSL helpers removed

Build Path directly instead:

// Before
$mem = path_memory();
$out = path_stdout(['stream' => 'output']);

// After
$mem = path('memory://' . bin2hex(random_bytes(16)) . '.memory');
$out = path('stdout://' . bin2hex(random_bytes(16)) . '.stdout', ['stream' => 'output']);

#14) flow-php/etl - ConfigBuilder::cacheFilesystem() and externalSortFilesystem() added

Point cache and external-sort mechanisms at any mounted protocol; defaults remain 'file'. The CacheConfig and SortConfig value objects expose the chosen protocol as ->filesystemProtocol.

$config = config_builder()
    ->mount(aws_s3_filesystem($bucket, $client, protocol: 'sort-scratch'))
    ->externalSortFilesystem('sort-scratch')
    ->build();

#15) flow-php/symfony-http-foundation-bridge - Output interface collapsed to a single loader(Path)

Output::memoryLoader(string $id) and Output::stdoutLoader() were replaced by Output::loader(Path $path). FlowBufferedResponse gained a string $filesystem = 'memory' constructor argument (buffer protocol); FlowStreamedResponse gained string $stdoutFilesystemProtocol = 'stdout'. Each response builds the path with its configured protocol and passes it to the Output.

// Before
new FlowBufferedResponse($extractor, new CsvOutput(), $transformations);

// After — same defaults, new constructor param available
new FlowBufferedResponse($extractor, new CsvOutput(), $transformations, filesystem: 'memory');

#16) flow-php/filesystem - StdOutFilesystem tracks open streams per php:// target

Previously the "only one stdout stream" guard lived in FilesystemStreams (ETL core) and fired when two writing streams used the stdout:// protocol. The check now lives in StdOutFilesystem itself and is precise per underlying php:// target (stdout / stderr / output): two streams with ['stream' => 'stdout'] conflict; one stdout stream + one stderr stream do not. Error message changed from "Only one stdout filesystem stream can be open at the same time" to "Only one stream can be open at the same time for php: //{target}".

#Upgrading from 0.34.x to 0.35.x

#1) flow-php/postgresql - DataType renamed to ColumnType

The DataType class used for schema/DDL definitions has been renamed to ColumnType to better communicate its purpose. All related DSL functions have been renamed from data_type_* to column_type_*.

Before:

use Flow\PostgreSql\QueryBuilder\Schema\DataType;
use function Flow\PostgreSql\DSL\data_type_integer;
use function Flow\PostgreSql\DSL\data_type_varchar;

column('age', data_type_integer());
column('name', data_type_varchar(255));
cast(ref('id'), DataType::bigint());

After:

use Flow\PostgreSql\QueryBuilder\Schema\ColumnType;
use function Flow\PostgreSql\DSL\column_type_integer;
use function Flow\PostgreSql\DSL\column_type_varchar;

column('age', column_type_integer());
column('name', column_type_varchar(255));
cast(ref('id'), ColumnType::bigint());

#2) flow-php/postgresql - PostgreSqlType renamed to ValueType

The PostgreSqlType enum used for value binding/casting has been renamed to ValueType to better communicate its purpose. All related DSL functions have been renamed from pgsql_type_* to value_type_*.

Before:

use Flow\PostgreSql\Client\Types\PostgreSqlType;
use function Flow\PostgreSql\DSL\pgsql_type_uuid;
use function Flow\PostgreSql\DSL\pgsql_type_text_array;

typed('550e8400-e29b-41d4-a716-446655440000', pgsql_type_uuid());
typed(['tag1', 'tag2'], pgsql_type_text_array());
typed(42, PostgreSqlType::INT4);

After:

use Flow\PostgreSql\Client\Types\ValueType;
use function Flow\PostgreSql\DSL\value_type_uuid;
use function Flow\PostgreSql\DSL\value_type_text_array;

typed('550e8400-e29b-41d4-a716-446655440000', value_type_uuid());
typed(['tag1', 'tag2'], value_type_text_array());
typed(42, ValueType::INT4);

#Upgrading from 0.31.x to 0.32.x

#1) Removal of Meilisearch Adapter

The Meilisearch adapter has been removed from Flow PHP. If you were using it, please migrate to Elasticsearch adapter.

#2) Removed deprecated DSL functions

All type-related DSL functions have been moved from Flow\ETL\DSL to Flow\Types\DSL. Update your imports accordingly.

#3) Removed deprecated DataFrame methods

#4) Removed deprecated Schema methods

#5) Removed deprecated Definition methods

This applies to all Definition implementations: BooleanDefinition, DateDefinition, DateTimeDefinition, EnumDefinition, FloatDefinition, HTMLDefinition, HTMLElementDefinition, IntegerDefinition, JsonDefinition, ListDefinition, MapDefinition, StringDefinition, StructureDefinition, TimeDefinition, UuidDefinition, XMLDefinition, XMLElementDefinition.

#6) Removed deprecated FileExtractor and PathFiltering methods

#7) Removed deprecated ScalarFunctionChain methods

#8) Removed deprecated Config constants

#9) Removed deprecated Transformers

#10) Removed deprecated classes

#Upgrading from 0.28.x to 0.29.x

#1) JsonType now uses Json value object instead of string

The JsonType has been refactored to use a dedicated Json value object (similar to Uuid/UuidType pattern). This allows static analysis tools to distinguish between regular strings and JSON strings.

Breaking Changes:

• JsonType::assert() now returns Json instance instead of string
• JsonType::cast() now returns Json instance instead of string
• JsonType::isValid() now checks for Json instance (plain strings are no longer valid)
• Cast::cast('json', $value) function now returns Json object instead of string
• type_json() return type annotation changed from Type<string> to Type<Json>
• JsonEntry::value() now returns ?Json instead of ?array (consistent with UuidEntry::value() returning ?Uuid)
• JsonEntry::json() method removed (use value() instead)

Migration:

If you were using type_json()->cast($value) and expected a string, use ->toString():

Before:

$jsonString = type_json()->cast($array); // was string

After:

$json = type_json()->cast($array); // now Json object
$jsonString = $json->toString(); // get the string
$jsonArray = $json->toArray(); // get as array

If you were using JsonEntry::value() and expected an array:

Before:

$entry = json_entry('data', ['key' => 'value']);
$array = $entry->value(); // was array

After:

$entry = json_entry('data', ['key' => 'value']);
$json = $entry->value(); // now Json object
$array = $json?->toArray(); // get as array
$string = $json?->toString(); // get as string

If you were using JsonEntry::json():

Before:

$json = $entry->json();

After:

$json = $entry->value(); // json() method removed, use value() instead

New Json value object features:

use Flow\Types\Value\Json;

// Create from string
$json = new Json('{"key": "value"}');

// Create from array
$json = Json::fromArray(['key' => 'value']);

// Check if valid JSON
Json::isValid('{"key": "value"}'); // true

// Convert to string/array
$json->toString(); // '{"key":"value"}'
$json->toArray(); // ['key' => 'value']

// Json implements Stringable
(string) $json; // '{"key":"value"}'

// Json implements JsonSerializable
json_encode($json); // '{"key":"value"}'

Note: JsonEntry::value() now returns ?Json for consistency with UuidEntry::value() returning ?Uuid. Use ->toArray() or ->toString() on the Json object to get the underlying data.

Row methods behavior:

// Row::toArray() converts Json to array automatically (for convenient serialization)
$row->toArray();           // Returns ['data' => ['key' => 'value']] not ['data' => Json(...)]

// Row::valueOf() returns the raw value (Json object for json entries)
$row->valueOf('data');     // Returns Json object (use ->toArray() if you need array)

// Entry value() returns the typed value
$row->get('data')->value();  // Returns Json object (use ->toArray() if you need array)

#Upgrading from 0.26.x to 0.27.x

#1) Force EntryFactory $entryFactory to be required on array_to_row & array_to_row(s)

Before:

to_entry('name', 'data');
array_to_row([]);
array_to_rows([]);

After:

to_entry('name', 'data', flow_context(config())->entryFactory());
array_to_row([], flow_context(config())->entryFactory());
array_to_rows([], flow_context(config())->entryFactory());

#Upgrading from 0.16.x to 0.17.x

#1) Removed $nullable property from all types

Before:

type_string(nullable:true)->toString() // ?string

After:

type_optional(string())->toString() // ?string

#2) Removed precision from float_type()

Before float_type() use to have default precision 6. This means that any operations on float had to round values to given precision. The problem with this approach is that all operations now need to receive a dedicated rounding option.

Instead, end users should handle precision of float columns through round() scalar function.

#3) Moved all Types to Flow\Types\Type namespace

Before

\Flow\ETL\DSL\type_string(); // now deprecated, alias for \Flow\Types\DSL\type_string();

After

\Flow\Types\DSL\type_string();

#Upgrading from 0.15.x to 0.16.x

#1) Deprecated Flow\ETL\DataFrame::renameAll* methods

Methods:

• Flow\ETL\DataFrame::renameAll(),
• Flow\ETL\DataFrame::renameAllLowerCase(),
• Flow\ETL\DataFrame::renameAllUpperCase(),
• Flow\ETL\DataFrame::renameAllUpperCaseFirst(),
• Flow\ETL\DataFrame::renameAllUpperCaseWord(),

Were deprecated in favor of using new method: DataFrame::renameEach() with proper RenameEntryStrategy object.

#2) Deprecated RenameAllCaseTransformer & RenameStrReplaceAllEntriesTransformer

Selected transformers were deprecated in favor of using DataFrame::renameEach() with related RenameEntryStrategy:

• RenameAllCaseTransformer -> RenameCaseTransformer,
• RenameStrReplaceAllEntriesTransformer -> RenameReplaceStrategy,

#Upgrading from 0.14.x to 0.15.x

#1) Removed Flow\ETL\Row\Schema\Matcher and implementations

Schema Matcher was the initial attempt to implement a schema evolution next to schema validation that over time got replaced with a different implementation of Schema Validator.

#2) Renamed Flow\ETL\Row\Schema namespace into Flow\ETL\Schema.

This means all classes related to Schema now live under Flow\ETL\Schema namespace.

#Upgrading from 0.11.x to 0.14.x

#1) Replaced Flow\ETL\DataFrame::validate() with Flow\ETL\DataFrame::match()

The old method is now deprecated and will be removed in the next release.

#2) Replaced Flow\ETL\Function\ScalarFunction\TypedScalarFunction with

Flow\ETL\Function\ScalarFunction\ScalarResult.

The old interface was used to allow defining the return type of the ScalarFunctions. It was replaced with a ScalarResult value object that is much more flexible than the interface, because it's allowing to return any type dynamically without making the scalar function stateful.

#Upgrading from 0.10.x to 0.11.x

#1) Removed StructureElement/struct_element/structure_element from StructureType Definition

Before:

type_structure([
    struct_element('name', string()),
    struct_element('age', integer()),
]);

After:

type_structure([
    'name' => string(),
    'age' => integer(),
]);

#2) Doctrine DBAL Adapter

From now options for:

• to_dbal_table_insert()
• to_db_table_update()

are passed as objects (instance of UpdateOptions|InsertOptions interfaces) and they are platform specific, so please use the proper class for the platform you are using.

• PostgreSQL
  • PostgreSQLInsertOptions
  • PostgreSQLUpdateOptions
• MySQL
  • MySQLInsertOptions
  • MySQLUpdateOptions
• Sqlite
  • SQLiteInsertOptions
  • SQLiteUpdateOptions

#Upgrading from 0.8.x to 0.10.x

#1) Providing multiple paths to a single extractor

From now to read from multiple locations use from_all(Extractor ...$extractors) : Exctractor extractor.

Before:

<?php

from_parquet([
    path(__DIR__ . '/data/1.parquet'),
    path(__DIR__ . '/data/2.parquet'),
]);

After:

<?php

from_all(
    from_parquet(path(__DIR__ . '/data/1.parquet')),
    from_parquet(path(__DIR__ . '/data/2.parquet')),
);

#2) Passing optional arguments to extractors/loaders

From now all extractors/loaders are accepting only mandatory arguments, all optional arguments should be passed through with* methods and fluent interface.

Before:

<?php

from_parquet(path(__DIR__ . '/data/1.parquet'), schema: $schema);

After:

<?php

from_parquet(path(__DIR__ . '/data/1.parquet'))->withSchema($schema);

#Upgrading from 0.7.x to 0.8.x

#1) Joins

To support joining bigger datasets, we had to move from initial NestedLoop join algorithm into Hash Join algorithm.

• the only supported coin expression is = (equals) that can be grouped with AND and OR operators.
• joinPrefix is now always required, and by default is set to 'joined_'
• join will always result all columns from both datasets, columns used in join condition will be prefixed with joinPrefix.

Other than that, API stays the same.

Above changes were introduced in all 3 types of joins:

• DataFrame::join()
• DataFrame::joinEach()
• DataFrame::crossJoin()

#2) GroupBy

From now on, DataFrame::groupBy() method will return GroupedDataFrame object, which is nothing more than a GroupBy statement Builder. To get the results, you first need to define the aggregation functions or optionally pivot the data.

#Upgrading from 0.6.x to 0.7.x

#1) DataFrame::appendSafe () method was removed

DataFrame::appendSafe() aka DataFrame::threadSafe() method was removed as it was introducing additional complexity and was not used in any of the adapters.

#Upgrading from 0.5.x to 0.6.x

#1) Rows::merge () accepts single instance of Rows

Before:

Rows::merge(Rows ...$rows) : Rows

After:

Rows::merge(Rows $rows) : Rows

#Upgrading from 0.4.x to 0.5.x

#1) Entry factory moved from extractors to FlowContext

To improve code quality and reduce code coupling EntryFactory was removed from all constructors of extractors, in favor of passing it into FlowContext & re-using same entry factory in a whole pipeline.

#2) Invalid schema has no fallback in NativeEntryFactory

Before, passing Schema into NativeEntryFactory::create() had fallback when the given entry was not found in a passed schema, now the schema has higher priority & fallback is no longer available, instead when the definition is missing in a passed schema, InvalidArgumentException will be thrown.

#3) BufferLoader was removed

BufferLoader was removed in favor of DataFrame::collect(int $batchSize = null) method which now accepts additional argument $batchSize that will keep collecting Rows from Extractor until the given batch size is reached. Which does exactly the same thing as BufferLoader did, but in a more generic way.

#4) Pipeline Closure

Pipeline Closure was reduced to be only Loader Closure and it was moved to \Flow\ETL\Loader namespace. Additionally, \Closure::close method no longer requires Rows to be passed as an argument.

#5) Parallelize

DataFrame::parallelize () method is deprecated, and it will be removed, instead use DataFrame::batchSize (int $size) method.

#6) Rows in batch - Extractors

From now, file-based Extractors will always throw one Row at time, in order to merge them into bigger groups use DataFrame::batchSize(int $size) just after extractor method.

Before:

<?php

(new Flow())
    ->read(CSV::from(__DIR__ . '/1_mln_rows.csv', rows_in_batch: 100))
    ->write(To::output())
    ->count();

After:

(new Flow())
    ->read(CSV::from(__DIR__ . '/1_mln_rows.csv',))
    ->batchSize(100)
    ->write(To::output())
    ->count();

Affected extractors:

• CSV
• Parquet
• JSON
• Text
• XML
• Avro
• DoctrineDBAL - rows_in_batch wasn't removed, but now results are thrown row by row, instead of whole page.
• GoogleSheet

#7) GoogleSheetExtractor

Argument $rows_in_batch was renamed to $rows_per_page which no longer determines the size of the batch, but the size of the page that will be fetched from Google API. Rows are yielded one by one.

#8) DataFrame::threadSafe() method was replaced by DataFrame::appendSafe()

DataFrame::appendSafe() is doing exactly the same thing as the old method, it's just more descriptive and self-explanatory. It's no longer mandatory to set this flat to true when using SaveMode::APPEND, it's now set automatically.

#9) Loaders - chunk size

Loaders are no longer accepting chunk_size parameter, from now in order to control the number of rows saved at once use DataFrame::batchSize(int $size) method.

#10) Removed DSL functions: datetime_string(), json_string()

Those functions were removed in favor of accepting string values in related DSL functions:

• datetime_string() => datetime(),
• json_string() => json() & json_object()

#11) Removed Asynchronous Processing

More details can be found in this issue.

• Removed etl-adapter-amphp
• Removed etl-adapter-reactphp
• Removed LocalSocketPipeline
• Removed DataFrame::pipeline()

#12) CollectionEntry removal

After adding native & logical types into the Flow, we remove the CollectionEntry as obsolete. New types that cover it better are: ListType, MapType & StructureType along with related new entry types.

#13) Removed from*() methods from scalar entries

Removed BooleanEntry::from(), FloatEntry::from(), IntegerEntry::from(), StringEntry::fromDateTime() methods in favor of using DSL functions.

#14) Removed deprecated Sha1IdFactory

Class Sha1IdFactory was removed, use HashIdFactory class:

(new HashIdFactory('entry_name'))->withAlgorithm('sha1');

#15) Deprecate DSL Static classes

DSL static classes were deprecated in favor of using functions defined in src/core/etl/src/Flow/ETL/DSL/functions.php file.

Deprecated classes:

• src/core/etl/src/Flow/ETL/DSL/From.php
• src/core/etl/src/Flow/ETL/DSL/Handler.php
• src/core/etl/src/Flow/ETL/DSL/To.php
• src/core/etl/src/Flow/ETL/DSL/Transform.php
• src/core/etl/src/Flow/ETL/DSL/Partitions.php
• src/adapter/etl-adapter-avro/src/Flow/ETL/DSL/Avro.php
• src/adapter/etl-adapter-chartjs/src/Flow/ETL/DSL/ChartJS.php
• src/adapter/etl-adapter-csv/src/Flow/ETL/DSL/CSV.php
• src/adapter/etl-adapter-doctrine/src/Flow/ETL/DSL/Dbal.php
• src/adapter/etl-adapter-elasticsearch/src/Flow/ETL/DSL/Elasticsearch.php
• src/adapter/etl-adapter-google-sheet/src/Flow/ETL/DSL/GoogleSheet.php
• src/adapter/etl-adapter-json/src/Flow/ETL/DSL/Json.php
• src/adapter/etl-adapter-meilisearch/src/Flow/ETL/DSL/Meilisearch.php
• src/adapter/etl-adapter-parquet/src/Flow/ETL/DSL/Parquet.php
• src/adapter/etl-adapter-text/src/Flow/ETL/DSL/Text.php
• src/adapter/etl-adapter-xml/src/Flow/ETL/DSL/XML.php

#Upgrading from 0.3.x to 0.4.x

#1) Transformers replaced with scalar functions

Transformers are a really powerful tool that was used in Flow since the beginning, but that tool was too powerful for the simple cases that were needed, and introduced additional complexity and maintenance issues when they were handwritten.

We reworked most of the internal transformers to new scalar functions and entry scalar functions (based on the built-in functions), and we still internally use that powerful tool, but we don't expose it to end users, instead, we provide easy-to-use, covering all user needs functions.

All available functions can be found in ETL\Row\Function folder or in ETL\DSL\functions file, and entry scalar functions are defined in EntryScalarFunction.

Before:

<?php

use Flow\ETL\Extractor\MemoryExtractor;
use Flow\ETL\Flow;
use Flow\ETL\DSL\Transform;

(new Flow())
    ->read(new MemoryExtractor())
    ->rows(Transform::string_concat(['name', 'last name'], ' ', 'name'))

After:

<?php

use function Flow\ETL\DSL\concat;
use function Flow\ETL\DSL\lit;
use Flow\ETL\Extractor\MemoryExtractor;
use Flow\ETL\Flow;

(new Flow())
    ->read(new MemoryExtractor())
    ->withEntry('name', concat(ref('name'), lit(' '), ref('last name')))

#2) ref function nullability

ref("entry_name") is no longer returning null when the entry is not found. Instead, it throws an exception. The same behavior can be achieved through using a newly introduced optional function:

Before:

<?php

use function Flow\ETL\DSL\optional;
use function Flow\ETL\DSL\ref;

ref('non_existing_column')->cast('string'); 

After:

<?php

use function Flow\ETL\DSL\optional;
use function Flow\ETL\DSL\ref;

optional(ref('non_existing_column'))->cast('string');
// or  
optional(ref('non_existing_column')->cast('string'));

#3) Extractors output

Affected extractors:

• CSV
• JSON
• Avro
• DBAL
• GoogleSheet
• Parquet
• Text
• XML

Extractors are no longer returning data under an array entry called row, thanks to this unpacking row become redundant.

Because of that all DSL functions are no longer expecting $entry_row_name parameter, if it was used anywhere, please remove it.

Before:

<?php 

(new Flow())
    ->read(From::array([['id' => 1, 'array' => ['a' => 1, 'b' => 2, 'c' => 3]]]))
    ->withEntry('row', ref('row')->unpack())
    ->renameAll('row.', '')
    ->drop('row')
    ->withEntry('array', ref('array')->arrayMerge(lit(['d' => 4])))
    ->write(To::memory($memory = new ArrayMemory()))
    ->run();

After:

<?php

(new Flow())
    ->read(From::array([['id' => 1, 'array' => ['a' => 1, 'b' => 2, 'c' => 3]]]))
    ->withEntry('array', ref('array')->arrayMerge(lit(['d' => 4])))
    ->write(To::memory($memory = new ArrayMemory()))
    ->run();

#4) ConfigBuilder::putInputIntoRows () output is now prefixed with _ (underscore)

In order to avoid collisions with datasets columns, additional columns created after using putInputIntoRows () would now be prefixed with _ (underscore) symbol.

Before:

<?php

$rows = (new Flow(Config::builder()->putInputIntoRows()))
            ->read(Json::from(__DIR__ . '/../Fixtures/timezones.json', 5))
            ->fetch();

foreach ($rows as $row) {
    $this->assertSame(
        [
            ...
            '_input_file_uri',
        ],
        \array_keys($row->toArray())
    );
}

After:

<?php

$rows = (new Flow(Config::builder()->putInputIntoRows()))
            ->read(Json::from(__DIR__ . '/../Fixtures/timezones.json', 5))
            ->fetch();

foreach ($rows as $row) {
    $this->assertSame(
        [
            ...
            '_input_file_uri',
        ],
        \array_keys($row->toArray())
    );
}

Found a typo or an outdated section? Edit this page on GitHub ↗