mirror of
https://github.com/zitadel/zitadel.git
synced 2025-12-24 01:56:49 +00:00
cccfc816f6
This pull request introduces a significant refactoring of the database interaction layer, focusing on improving explicitness, transactional control, and error handling. The core change is the removal of the stateful `QueryExecutor` from repository instances. Instead, it is now passed as an argument to each method that interacts with the database. This change makes transaction management more explicit and flexible, as the same repository instance can be used with a database pool or a specific transaction without needing to be re-instantiated. ### Key Changes - **Explicit `QueryExecutor` Passing:** - All repository methods (`Get`, `List`, `Create`, `Update`, `Delete`, etc.) in `InstanceRepository`, `OrganizationRepository`, `UserRepository`, and their sub-repositories now require a `database.QueryExecutor` (e.g., a `*pgxpool.Pool` or `pgx.Tx`) as the first argument. - Repository constructors no longer accept a `QueryExecutor`. For example, `repository.InstanceRepository(pool)` is now `repository.InstanceRepository()`. - **Enhanced Error Handling:** - A new `database.MissingConditionError` is introduced to enforce required query conditions, such as ensuring an `instance_id` is always present in `UPDATE` and `DELETE` operations. - The database error wrapper in the `postgres` package now correctly identifies and wraps `pgx.ErrTooManyRows` and similar errors from the `scany` library into a `database.MultipleRowsFoundError`. - **Improved Database Conditions:** - The `database.Condition` interface now includes a `ContainsColumn(Column) bool` method. This allows for runtime checks to ensure that critical filters (like `instance_id`) are included in a query, preventing accidental cross-tenant data modification. - A new `database.Exists()` condition has been added to support `EXISTS` subqueries, enabling more complex filtering logic, such as finding an organization that has a specific domain. - **Repository and Interface Refactoring:** - The method for loading related entities (e.g., domains for an organization) has been changed from a boolean flag (`Domains(true)`) to a more explicit, chainable method (`LoadDomains()`). This returns a new repository instance configured to load the sub-resource, promoting immutability. - The custom `OrgIdentifierCondition` has been removed in favor of using the standard `database.Condition` interface, simplifying the API. - **Code Cleanup and Test Updates:** - Unnecessary struct embeddings and metadata have been removed. - All integration and repository tests have been updated to reflect the new method signatures, passing the database pool or transaction object explicitly. - New tests have been added to cover the new `ExistsDomain` functionality and other enhancements. These changes make the data access layer more robust, predictable, and easier to work with, especially in the context of database transactions.
88 lines
2.1 KiB
Go
88 lines
2.1 KiB
Go
package database
|
|
|
|
import (
|
|
"context"
|
|
)
|
|
|
|
// Pool is a connection pool. e.g. pgxpool
|
|
type Pool interface {
|
|
Beginner
|
|
QueryExecutor
|
|
Migrator
|
|
|
|
Acquire(ctx context.Context) (Connection, error)
|
|
Close(ctx context.Context) error
|
|
|
|
Ping(ctx context.Context) error
|
|
}
|
|
|
|
type PoolTest interface {
|
|
Pool
|
|
// MigrateTest is the same as [Migrator] but executes the migrations multiple times instead of only once.
|
|
MigrateTest(ctx context.Context) error
|
|
}
|
|
|
|
// Connection is a single database connection which can be released back to the pool.
|
|
type Connection interface {
|
|
Beginner
|
|
QueryExecutor
|
|
Migrator
|
|
|
|
Release(ctx context.Context) error
|
|
|
|
Ping(ctx context.Context) error
|
|
}
|
|
|
|
// Querier is a database client that can execute queries and return rows.
|
|
type Querier interface {
|
|
Query(ctx context.Context, stmt string, args ...any) (Rows, error)
|
|
QueryRow(ctx context.Context, stmt string, args ...any) Row
|
|
}
|
|
|
|
// Executor is a database client that can execute statements.
|
|
// It returns the number of rows affected or an error
|
|
type Executor interface {
|
|
Exec(ctx context.Context, stmt string, args ...any) (int64, error)
|
|
}
|
|
|
|
// QueryExecutor is a database client that can execute queries and statements.
|
|
type QueryExecutor interface {
|
|
Querier
|
|
Executor
|
|
}
|
|
|
|
// Scanner scans a single row of data into the destination.
|
|
type Scanner interface {
|
|
Scan(dest ...any) error
|
|
}
|
|
|
|
// Row is an abstraction of sql.Row.
|
|
type Row interface {
|
|
Scanner
|
|
}
|
|
|
|
// Rows is an abstraction of sql.Rows.
|
|
type Rows interface {
|
|
Scanner
|
|
Next() bool
|
|
Close() error
|
|
Err() error
|
|
}
|
|
|
|
type CollectableRows interface {
|
|
// Collect collects all rows and scans them into dest.
|
|
// dest must be a pointer to a slice of pointer to structs
|
|
// e.g. *[]*MyStruct
|
|
// Rows are closed after this call.
|
|
Collect(dest any) error
|
|
// CollectFirst collects the first row and scans it into dest.
|
|
// dest must be a pointer to a struct
|
|
// e.g. *MyStruct{}
|
|
// Rows are closed after this call.
|
|
CollectFirst(dest any) error
|
|
// CollectExactlyOneRow collects exactly one row and scans it into dest.
|
|
// e.g. *MyStruct{}
|
|
// Rows are closed after this call.
|
|
CollectExactlyOneRow(dest any) error
|
|
}
|