# PODNAME: Neo4j::Driver::TODO
# ABSTRACT: Information on planned improvements to Neo4j::Driver

=encoding utf8

=head1 TODO

=head2 Address open issues on GitHub

See L<https://github.com/johannessen/neo4j-driver-perl/issues>.

=head2 Functionality and API


=item * Implement spatial and temporal types.

=item * Add timers to L<Neo4j::Driver::ResultSummary> (see C<Neo4j::Bolt>).

=item * C<croak()> error objects (e. g. L<Exception::Class>) instead of strings.
It seems there are about four types that would need to be distinguished: illegal
usage errors, internal driver errors, Network errors, and Neo4j server errors.
See also L<#7|https://github.com/johannessen/neo4j-driver-perl/issues/7>.


=head2 Experimental features


=item * L<Neo4j::Driver/"Parameter syntax conversion">: make stable and move
filter implementation to C<Transaction> in preparation of Bolt v3 support

=item * L<Neo4j::Driver/"Type system customisation">: make illegal, but
create a new config option that continues to provide C<init> functionality
(same flexibility, simpler API)

=item * L<Neo4j::Driver::Session/"Calling in list context">: make illegal

=item * L<Neo4j::Driver::Session/"Concurrent transactions">: make illegal
for both nested explicit and nested autocommit transactions (for
consistency with Bolt), but provide a driver config option (e. g.
C<< nested_transactions => 1 >>) that lifts this restriction for HTTP

=item * L<Neo4j::Driver::Transaction/"Calling in list context">: make illegal

=item * L<Neo4j::Driver::Transaction/"Execute multiple statements at once">:
This feature should no longer be exposed to the client. It complicates the API
significantly and is not that big of an optimisation anyway, because results
are typically fetched I<before> the next statement is run.

=item * L<Neo4j::Driver::Transaction/"Return results in graph format">,
L<Neo4j::Driver::Record/"graph">: make driver config option

=item * Calling list methods in scalar context
(L<in Node|Neo4j::Driver::Type::Node/"Calling in scalar context">,
L<in Path|Neo4j::Driver::Type::Path/"Calling in scalar context">,
L<in Result|Neo4j::Driver::Result/"Calling in scalar context">, and
L<in ResultSummary|Neo4j::Driver::ResultSummary/"Calling in scalar context">)
should probably generally behave the same way using a list in scalar
context would: It should return the number of items in the list.


=head2 Tests, code quality, documentation


=item * Test roundtrip of special numeric values
(very large integers, -0.0, ±Inf, ±NaN).

=item * Convert tests in C<xt/compatibility> to use L<Module::Load>, so that
testing/dev dependencies are fewer.

=item * Improve test coverage:


=item * Many yet uncovered code paths are obviously fine, but difficult or
impossible to cover. In some of these cases, it may be possible to refactor the
code, such as by banking on autovivification (i.e. don't defend against undefined
C<$a> in expressions like C<< $a->{b} >>; see L<perlref/"Using References">).

=item * The C<deep_bless> subs contain a lot of assertions and other checks
that are not normally necessary. Since this logic seems to work fine, it should
be simplified. (This may also make it easier to unroll the recursion later.)

=item * The current policy of not documenting deprecated methods is informed by
the principle to "design interfaces that are: consistent; easy to use correctly;
hard to use incorrectly". Perhaps simply listing the deprecated method names
with short note like "deprecated in 0.13" would be an acceptable addition that
also fulfils the B<pod> coverage requirements.

=item * Documenting each attribute in L<Neo4j::Driver::SummaryCounters> as individual
methods might be a quick way to bring up the B<pod> coverage stats a bit.


=item * Neo4j::Test should auto-detect the Neo4j server version and
set the C<cypher_filter> config option accordingly.

=item * Neo4j::Sim should implement the driver HTTP net module API instead
of the L<REST::Client> API, so that we can eventually replace REST::Client.

=item * Write new unit tests for all modules.

=item * Optimise the simulator for C<$hash = 0>.
Use of C<<< << >>> causes statements to end with C<\n>, which the simulator
could filter out. 
The internals test "transaction: REST 404 error handling" should run a distinct

=item * Try to change "no connection" tests such that no C<NXDOMAIN> responses
are required by (ab)using a particular port number on localhost; the port could
be checked beforehand and the test skipped if it happens to be open for some
reason. Alternatively, the tests in question could be changed to a simulated
connection failure.

=item * Verify that L<Neo4j::Driver::Type::Node/"get"> and
L<Neo4j::Driver::Type::Relationship/"get"> really do return undef
(as documented), even when called in list context.

=item * Add test for byte arrays (C<RETURN apoc.text.bytes("DATA") AS x>).

=item * Check that nodes without labels and nodes without properties are
handled correctly in all aspects (there I<might> be issues with perlbolt).

=item * Check that after a server error, the next statement will succeed
(there I<might> be issues with perlbolt; see

=item * List possible C<croak> output in L<Neo4j::Driver/"DIAGNOSTICS">,
allowing for indexing by search engines.

=item * L<Neo4j::Driver::ResultSummary/"notifications">: Clarify docs that
this method is to be called in list context.


=head1 Other ideas for specific modules

=head2 L<Neo4j::Driver>


=item * Make the URL a config option, so that it can be queried (and changed).

=item * Make the auth data a config option, so that it can be queried. As
alternative ways to I<set> the auth data, C<basic_auth()> should continue
to be supported as an alias and the user info should be parsed from the URL
if given (however, URLs without user info should not change the auth data
stored in the driver). A possible implementation would be to create a new
module that would offer suitable methods, but this seems like overkill.
That said, userinfo is actually forbidden now by
so this should perhaps not be added after all?

=item * Allow passing config options directly to the constructor, e. g. in
place of the URL (C<< Neo4j::Driver->new({ url=>"bolt:", timeout=>30 }) >>).

=item * Change the default URI scheme from HTTP to auto-detect, i. e. try
Bolt first, then HTTP in case of failure. This could be explicitly specified
as e. g. C<//localhost>.

=item * The C<neo4j> scheme could perhaps be mapped onto Bolt or onto the
default URL scheme, just so that C<neo4j://...> URLs will kind of work.

=item * Consider writing a concrete example that re-creates LOMS logic by
re-blessing the structural types into custom types from the business logic
using C<< $cypher_types->{init} >>. (For example, check for Neo4j nodes that
are labelled C<:Person> and re-bless those as C<Local::Person> or whatever.)


=head2 L<Neo4j::Driver::Session>


=item * Once a session is created, the driver object becomes immutable. It
should therefore be possible to store the ServerInfo in the driver object
once it is obtained. If the default database is added as well, the Discovery
API doesn't need to be used again for a new session. This change would keep
down network utilisation in scenarios where many sessions are created (such
as running the driver's test suite).

=item * Consider whether to offer
L<transaction functions|https://neo4j.com/docs/driver-manual/current/session-api/simple/#driver-simple-transaction-fn>.
If available, these should consist of subrefs passed to methods called
C<write_transaction> and C<read_transaction>. These access modes are only an
optimisation for Enterprise features. We don't target those at present, but
C<read_transaction> could then eventually be routed to a high-performance
read-only server once clusters are supported. It would make sense to offer
both methods right away even though initially they'd work exactly the same.


=head2 L<Neo4j::Driver::Transaction>


=item * Consider supporting re-using C<Record> objects for query parameters in
C<run>. The Java and C# drivers do this.

=item * Run statements lazily: Just like with the official drivers, statements
passed to C<run> should be gathered until their results are actually accessed.
Then, and only then, all statements gathered so far should be sent to the
server using a single request. Challenges of this approach include that
notifications are not associated with a single statement, so there must be an
option to disable this behaviour; indeed, disabled should probably be the
default when stats are requested. Additionally, there are some bugs with
multiple statements (see tests C<non-arrayref individual statement> and
C<include empty statement>). Since stats are now requested by default,
this item might mean investing time in developing an optimisation
feature that is almost never used. Since the server is often run on localhost
anyway where latency is very close to zero, this item should not have high

=item * The current API to
L<Neo4j::Driver::Transaction/"Execute multiple statements at once">
seems a bit too complicated, especially for something that is probably
hardly ever actually used in practice. It might make sense to provide a
dedicated method (e. g. C<_run_multiple()>) for just that purpose. This
would eventually free up the C<run()> implementation from unneeded baggage.
The dedicated method may be private as long as the plan still is to provide
this functionality by running statements lazily.


=head2 L<Neo4j::Driver::Record>


=item * Consider whether to implement methods to query the list of fields for
this record (C<keys>, C<has>, C<size>) and/or a mapping function for all fields
(C<map>/C<forEach>). Given that this data should easily be available through
the Result object, these seem slightly superfluous though.

=item * Implement C<graph>; see

=item * Add C<field()> as alias for C<get()>, enabling clients to avoid the
possibly confusing C<< $record->get->get >> pattern. The official drivers
only offer C<get()>, and C<field()> might be too similar to C<fields()> in
the official Java driver, so this alias should perhaps be experimental.


=head2 L<Neo4j::Driver::Result>


=item * Perhaps C<fetch()> should always buffer two records instead of just
one. With the current implementation, the bolt connection might remain
attached longer than desirable in cases where the client knows in advance
how many records there will be and calls C<fetch()> exactly that number of
times. (In theory, such a change might even slightly improve performance
if the driver uses Perl threads to fill the buffer in the background.)


=head2 L<Neo4j::Driver::ResultColumns>


=item * The entire package can probably be removed now.


=head2 L<Neo4j::Driver::ResultSummary>


=item * Profile the server-side performance penalty of requesting stats for
various kinds of queries. If the penalty turns out to be high, stats should
perhaps have to be requested explicitly by clients (rather than being
obtained by default, as with 0.13 and higher). However, using Bolt always
provides stats, and different APIs for HTTP and Bolt seem like a bad idea.


=head2 L<Neo4j::Driver::SummaryCounters>


=item * C<use Class::Accessor::Fast 0.34;>

=item * It seems Neo4j 4 added new counters for system updates.


=head2 L<Neo4j::Driver::Net::Bolt>


=item * Rollback behaviour on errors needs further study.
L<Neo4j Status Codes|https://neo4j.com/docs/status-codes/4.2/>
says that all errors have a rollback effect, but in at least some
cases, the effect seems to be merely to mark the tx as failed and
uncommittable, which isn't quite the same thing. This may or may not
vary across error types, Neo4j versions, or Bolt versions. OTOH, some
errors are internal client errors that shouldn't rollback the tx
Not sure if these occur in practice, but we should probably
be able to handle them correctly anyway.


=head2 L<Neo4j::Driver::Net::HTTP>


=item * Consider unrolling C<deep_bless> recursion. Based on initial profiling,
this may save up to about 5% CPU time (for a specific HTTP test query cached in
RAM, performance went from about 2700/s to 2850/s when skipping the call to
C<deep_bless> entirely). However, when accessing the database, the bottleneck
is typically I/O (querying Neo4j itself instead of the RAM-cached response let
the performance for the very same query drop down to 650/s when executed over
HTTP). So this optimisation may not be worth it (OTOH, Bolt performance was
something like 7000/s, so optimising C<deep_bless> may be more useful there).

=item * If a 201 is received without a C<Location> header, it is currently
simply ignored by C<_parse_tx_status()>. (The simulator requires this.)
According to RFC 7231, such a response means the location hasn't changed,
i. e. the resource has been created at the default transaction endpoint.
That should never happen; in fact, it should only ever happen for a PUT
request, but we don't use those here. So ignoring this is probably the right
choice. But it may still be useful to revisit this logic later on.

=item * Parse the C<expires> date for transactions, sync client and server
system dates using the C<Date> header and track transaction expiration.


=head2 Neo4j::Driver::Net::HTTP::*


=item * Profile whether C<X-Stream> has any performance impact. Remove if
in doubt, as we don't implement streaming (and have no plans to in the
future, considering that Bolt should be used when speed is important).

=item * Remove the L<REST::Client> dependency and use <LWP::UserAgent> directly.


=head2 Neo4j::Driver::Type::*


=item * The C<eq> and C<ne> operators should be overloaded to allow
for ID comparison on nodes and relationships.

=item * Consider whether to use C<use overload '%{}'> to allow direct
access to e. g. properties using the pre-0.13 hashref syntax. See
L<https://metacpan.org/pod/overload#Two-face-References> for an example.
L<perltie> might perhaps also work.
Note that L<overload> might be a memory hog; see L<Types::Serialiser/"BUGS">.

=item * Try to refactor L<Neo4j::Driver::Type::Path>'s internal representation
to allow either elements or nodes+rels. Have one autogenerate from the other,
then cache the results. May not actually have advantages for deep_bless though.

=item * Add C<property()> as alias for C<get()> in L<Neo4j::Driver::Type::Node>
and L<Neo4j::Driver::Type::Relationship>, enabling clients to avoid the
possibly confusing C<< $record->get->get >> pattern.