fix(eventstore): Make Eventstore Compatible with Relational Table Package (#10687)

Improves compatibility of eventstore and related database components
with the new relational table package.

## Which problems are solved

1. **Incompatible Database Interfaces**: The existing eventstore was
tightly coupled to the database package, which is incompatible with the
new, more abstract relational table package in v3. This prevented the
new command-side logic from pushing events to the legacy eventstore.
2. **Missing Health Checks**: The database interfaces in the new package
lacked a Ping method, making it impossible to perform health checks on
database connections.
3. **Event Publishing Logic**: The command handling logic in domain
needed a way to collect and push events to the legacy eventstore after a
command was successfully executed.

## How the problems are solved

1. **`LegacyEventstore` Interface**:
* A new `LegacyEventstore` interface is introduced in the new
`database/eventstore` . This interface exposes a `PushWithNewClient`
method that accepts the new `database.QueryExecutor` interface,
decoupling the v3 domain from the legacy implementation.
* The `internal/eventstore.Eventstore` now implements this interface. A
wrapper, PushWithClient, is added to convert the old database client
types (`*sql.DB`, `*sql.Tx`) into the new `QueryExecutor` types before
calling `PushWithNewClient`.
2. **Database Interface Updates**:
* The `database.Pool` and `database.Client` interfaces in
`storage/eventstore` have been updated to include a Ping method,
allowing for consistent health checks across different database
dialects.
* The `postgres` and `sql` dialect implementations have been updated to
support this new method.
3. **Command and Invoker Refactoring**:
* The `Commander` interface in domain now includes an `Events()
[]legacy_es.Command` method. This allows commands to declare which
events they will generate.
* The `eventCollector` in the invoker logic has been redesigned. It now
ensures a database transaction is started before executing a command.
After successful execution, it calls the `Events()` method on the
command to collect the generated events and appends them to a list.
* The `eventStoreInvoker` then pushes all collected events to the legacy
eventstore using the new `LegacyEventstore` interface, ensuring that
events are only pushed if the entire command (and any sub-commands)
executes successfully within the transaction.
4. **Testing**:
* New unit tests have been added for the invoker to verify that events
are correctly collected from single commands, batched commands, and
nested commands.

These changes create a clean bridge between the new v3 command-side
logic and the existing v1 eventstore, allowing for incremental adoption
of the new architecture while maintaining full functionality.

## Additional Information

closes https://github.com/zitadel/zitadel/issues/10442

backend/v3/storage/database/dialect/sql/conn.go

@@ -11,6 +11,10 @@ type sqlConn struct {
 	*sql.Conn
 }
 
+func SQLConn(conn *sql.Conn) database.Client {
+	return &sqlConn{Conn: conn}
+}
+
 var _ database.Client = (*sqlConn)(nil)
 
 // Release implements [database.Client].
@@ -24,7 +28,7 @@ func (c *sqlConn) Begin(ctx context.Context, opts *database.TransactionOptions)
 	if err != nil {
 		return nil, wrapError(err)
 	}
-	return &sqlTx{tx}, nil
+	return &Transaction{tx}, nil
 }
 
 // Query implements sql.Client.
@@ -54,6 +58,11 @@ func (c *sqlConn) Exec(ctx context.Context, sql string, args ...any) (int64, err
 	return res.RowsAffected()
 }
 
+// Ping implements [database.Pool].
+func (c *sqlConn) Ping(ctx context.Context) error {
+	return wrapError(c.PingContext(ctx))
+}
+
 // Migrate implements [database.Migrator].
 func (c *sqlConn) Migrate(ctx context.Context) error {
 	return ErrMigrate

backend/v3/storage/database/dialect/sql/pool.go

@@ -61,7 +61,12 @@ func (c *sqlPool) Begin(ctx context.Context, opts *database.TransactionOptions)
 	if err != nil {
 		return nil, wrapError(err)
 	}
-	return &sqlTx{tx}, nil
+	return &Transaction{tx}, nil
+}
+
+// Ping implements [database.Pool].
+func (c *sqlPool) Ping(ctx context.Context) error {
+	return wrapError(c.PingContext(ctx))
 }
 
 // Close implements [database.Pool].

backend/v3/storage/database/dialect/sql/tx.go

@@ -8,28 +8,28 @@ import (
 	"github.com/zitadel/zitadel/backend/v3/storage/database"
 )
 
-type sqlTx struct{ *sql.Tx }
+type Transaction struct{ *sql.Tx }
 
-var _ database.Transaction = (*sqlTx)(nil)
+var _ database.Transaction = (*Transaction)(nil)
 
-func SQLTx(tx *sql.Tx) *sqlTx {
-	return &sqlTx{
+func SQLTx(tx *sql.Tx) *Transaction {
+	return &Transaction{
 		Tx: tx,
 	}
 }
 
 // Commit implements [database.Transaction].
-func (tx *sqlTx) Commit(ctx context.Context) error {
+func (tx *Transaction) Commit(ctx context.Context) error {
 	return wrapError(tx.Tx.Commit())
 }
 
 // Rollback implements [database.Transaction].
-func (tx *sqlTx) Rollback(ctx context.Context) error {
+func (tx *Transaction) Rollback(ctx context.Context) error {
 	return wrapError(tx.Tx.Rollback())
 }
 
 // End implements [database.Transaction].
-func (tx *sqlTx) End(ctx context.Context, err error) error {
+func (tx *Transaction) End(ctx context.Context, err error) error {
 	if err != nil {
 		rollbackErr := tx.Rollback(ctx)
 		if rollbackErr != nil {
@@ -42,7 +42,7 @@ func (tx *sqlTx) End(ctx context.Context, err error) error {
 
 // Query implements [database.Transaction].
 // Subtle: this method shadows the method (Tx).Query of pgxTx.Tx.
-func (tx *sqlTx) Query(ctx context.Context, sql string, args ...any) (database.Rows, error) {
+func (tx *Transaction) Query(ctx context.Context, sql string, args ...any) (database.Rows, error) {
 	//nolint:rowserrcheck // Rows.Close is called by the caller
 	rows, err := tx.QueryContext(ctx, sql, args...)
 	if err != nil {
@@ -53,13 +53,13 @@ func (tx *sqlTx) Query(ctx context.Context, sql string, args ...any) (database.R
 
 // QueryRow implements [database.Transaction].
 // Subtle: this method shadows the method (Tx).QueryRow of pgxTx.Tx.
-func (tx *sqlTx) QueryRow(ctx context.Context, sql string, args ...any) database.Row {
+func (tx *Transaction) QueryRow(ctx context.Context, sql string, args ...any) database.Row {
 	return &Row{tx.QueryRowContext(ctx, sql, args...)}
 }
 
 // Exec implements [database.Transaction].
 // Subtle: this method shadows the method (Pool).Exec of pgxPool.Pool.
-func (tx *sqlTx) Exec(ctx context.Context, sql string, args ...any) (int64, error) {
+func (tx *Transaction) Exec(ctx context.Context, sql string, args ...any) (int64, error) {
 	res, err := tx.ExecContext(ctx, sql, args...)
 	if err != nil {
 		return 0, wrapError(err)
@@ -69,7 +69,7 @@ func (tx *sqlTx) Exec(ctx context.Context, sql string, args ...any) (int64, erro
 
 // Begin implements [database.Transaction].
 // As postgres does not support nested transactions we use savepoints to emulate them.
-func (tx *sqlTx) Begin(ctx context.Context) (database.Transaction, error) {
+func (tx *Transaction) Begin(ctx context.Context) (database.Transaction, error) {
 	_, err := tx.ExecContext(ctx, createSavepoint)
 	if err != nil {
 		return nil, wrapError(err)