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/postgres/conn.go

@@ -27,7 +27,7 @@ func (c *pgxConn) Begin(ctx context.Context, opts *database.TransactionOptions)
 	if err != nil {
 		return nil, wrapError(err)
 	}
-	return &pgxTx{tx}, nil
+	return &Transaction{tx}, nil
 }
 
 // Query implements sql.Client.
@@ -56,6 +56,11 @@ func (c *pgxConn) Exec(ctx context.Context, sql string, args ...any) (int64, err
 	return res.RowsAffected(), nil
 }
 
+// Ping implements [database.Pool].
+func (c *pgxConn) Ping(ctx context.Context) error {
+	return wrapError(c.Conn.Ping(ctx))
+}
+
 // Migrate implements [database.Migrator].
 func (c *pgxConn) Migrate(ctx context.Context) error {
 	if isMigrated {

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

@@ -62,7 +62,7 @@ func (c *pgxPool) Begin(ctx context.Context, opts *database.TransactionOptions)
 	if err != nil {
 		return nil, wrapError(err)
 	}
-	return &pgxTx{tx}, nil
+	return &Transaction{tx}, nil
 }
 
 // Close implements [database.Pool].
@@ -71,6 +71,11 @@ func (c *pgxPool) Close(_ context.Context) error {
 	return nil
 }
 
+// Ping implements [database.Pool].
+func (c *pgxPool) Ping(ctx context.Context) error {
+	return wrapError(c.Pool.Ping(ctx))
+}
+
 // Migrate implements [database.Migrator].
 func (c *pgxPool) Migrate(ctx context.Context) error {
 	if isMigrated {

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

@@ -9,24 +9,30 @@ import (
 	"github.com/zitadel/zitadel/backend/v3/storage/database"
 )
 
-type pgxTx struct{ pgx.Tx }
+type Transaction struct{ pgx.Tx }
 
-var _ database.Transaction = (*pgxTx)(nil)
+func PGxTx(tx pgx.Tx) *Transaction {
+	return &Transaction{
+		Tx: tx,
+	}
+}
+
+var _ database.Transaction = (*Transaction)(nil)
 
 // Commit implements [database.Transaction].
-func (tx *pgxTx) Commit(ctx context.Context) error {
+func (tx *Transaction) Commit(ctx context.Context) error {
 	err := tx.Tx.Commit(ctx)
 	return wrapError(err)
 }
 
 // Rollback implements [database.Transaction].
-func (tx *pgxTx) Rollback(ctx context.Context) error {
+func (tx *Transaction) Rollback(ctx context.Context) error {
 	err := tx.Tx.Rollback(ctx)
 	return wrapError(err)
 }
 
 // End implements [database.Transaction].
-func (tx *pgxTx) 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 {
@@ -39,7 +45,7 @@ func (tx *pgxTx) End(ctx context.Context, err error) error {
 
 // Query implements [database.Transaction].
 // Subtle: this method shadows the method (Tx).Query of pgxTx.Tx.
-func (tx *pgxTx) 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) {
 	rows, err := tx.Tx.Query(ctx, sql, args...)
 	if err != nil {
 		return nil, wrapError(err)
@@ -49,13 +55,13 @@ func (tx *pgxTx) 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 *pgxTx) 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.Tx.QueryRow(ctx, sql, args...)}
 }
 
 // Exec implements [database.Transaction].
 // Subtle: this method shadows the method (Pool).Exec of pgxPool.Pool.
-func (tx *pgxTx) 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.Tx.Exec(ctx, sql, args...)
 	if err != nil {
 		return 0, wrapError(err)
@@ -65,12 +71,12 @@ func (tx *pgxTx) 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 *pgxTx) Begin(ctx context.Context) (database.Transaction, error) {
+func (tx *Transaction) Begin(ctx context.Context) (database.Transaction, error) {
 	savepoint, err := tx.Tx.Begin(ctx)
 	if err != nil {
 		return nil, wrapError(err)
 	}
-	return &pgxTx{savepoint}, nil
+	return &Transaction{savepoint}, nil
 }
 
 func transactionOptionsToPgx(opts *database.TransactionOptions) pgx.TxOptions {