andwati/zitadel
1
0
Fork 0
mirror of https://github.com/andwati/zitadel.git synced 2026-11-09 23:55:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: database interaction and error handling (#10762)

Browse Source 
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.
This commit is contained in:
Silvan
2025-09-24 10:12:31 +00:00
committed by GitHub
parent 09d09ab337
commit cccfc816f6
53 changed files with 3893 additions and 1423 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/v3/storage/database/operators.go
+71 -78
View File
@@ -6,16 +6,40 @@ import (
"golang.org/x/exp/constraints"
)
type Value interface {
Boolean | Number | Text | Instruction
type wrappedValue[V Value] struct {
value V
fn function
}
func LowerValue[T Value](v T) wrappedValue[T] {
return wrappedValue[T]{value: v, fn: functionLower}
}
func SHA256Value[T Value](v T) wrappedValue[T] {
return wrappedValue[T]{value: v, fn: functionSHA256}
}
func (b wrappedValue[V]) WriteArg(builder *StatementBuilder) {
builder.Grow(len(b.fn) + 5)
builder.WriteString(string(b.fn))
builder.WriteRune('(')
builder.WriteArg(b.value)
builder.WriteRune(')')
}
var _ argWriter = (*wrappedValue[string])(nil)
type Value interface {
Boolean | Number | Text | Instruction | Bytes
}
//go:generate enumer -type NumberOperation,TextOperation,BytesOperation -linecomment -output ./operators_enumer.go
type Operation interface {
BooleanOperation | NumberOperation | TextOperation
NumberOperation | TextOperation | BytesOperation
}
type Text interface {
~string | ~[]byte
~string | Bytes
}
// TextOperation are operations that can be performed on text values.
@@ -23,60 +47,17 @@ type TextOperation uint8
const (
// TextOperationEqual compares two strings for equality.
TextOperationEqual TextOperation = iota + 1
// TextOperationEqualIgnoreCase compares two strings for equality, ignoring case.
TextOperationEqualIgnoreCase
TextOperationEqual TextOperation = iota + 1 // =
// TextOperationNotEqual compares two strings for inequality.
TextOperationNotEqual
// TextOperationNotEqualIgnoreCase compares two strings for inequality, ignoring case.
TextOperationNotEqualIgnoreCase
TextOperationNotEqual // <>
// TextOperationStartsWith checks if the first string starts with the second.
TextOperationStartsWith
// TextOperationStartsWithIgnoreCase checks if the first string starts with the second, ignoring case.
TextOperationStartsWithIgnoreCase
TextOperationStartsWith // LIKE
)
var textOperations = map[TextOperation]string{
TextOperationEqual: " = ",
TextOperationEqualIgnoreCase: " LIKE ",
TextOperationNotEqual: " <> ",
TextOperationNotEqualIgnoreCase: " NOT LIKE ",
TextOperationStartsWith: " LIKE ",
TextOperationStartsWithIgnoreCase: " LIKE ",
}
func writeTextOperation[T Text](builder *StatementBuilder, col Column, op TextOperation, value T) {
switch op {
case TextOperationEqual, TextOperationNotEqual:
col.WriteQualified(builder)
builder.WriteString(textOperations[op])
builder.WriteArg(value)
case TextOperationEqualIgnoreCase, TextOperationNotEqualIgnoreCase:
builder.WriteString("LOWER(")
col.WriteQualified(builder)
builder.WriteString(")")
builder.WriteString(textOperations[op])
builder.WriteString("LOWER(")
builder.WriteArg(value)
builder.WriteString(")")
case TextOperationStartsWith:
col.WriteQualified(builder)
builder.WriteString(textOperations[op])
builder.WriteArg(value)
func writeTextOperation[T Text](builder *StatementBuilder, col Column, op TextOperation, value any) {
writeOperation[T](builder, col, op.String(), value)
if op == TextOperationStartsWith {
builder.WriteString(" || '%'")
case TextOperationStartsWithIgnoreCase:
builder.WriteString("LOWER(")
col.WriteQualified(builder)
builder.WriteString(")")
builder.WriteString(textOperations[op])
builder.WriteString("LOWER(")
builder.WriteArg(value)
builder.WriteString(")")
builder.WriteString(" || '%'")
default:
panic("unsupported text operation")
}
}
@@ -89,48 +70,60 @@ type NumberOperation uint8
const (
// NumberOperationEqual compares two numbers for equality.
NumberOperationEqual NumberOperation = iota + 1
NumberOperationEqual NumberOperation = iota + 1 // =
// NumberOperationNotEqual compares two numbers for inequality.
NumberOperationNotEqual
NumberOperationNotEqual // <>
// NumberOperationLessThan compares two numbers to check if the first is less than the second.
NumberOperationLessThan
NumberOperationLessThan // <
// NumberOperationLessThanOrEqual compares two numbers to check if the first is less than or equal to the second.
NumberOperationAtLeast
NumberOperationAtLeast // <=
// NumberOperationGreaterThan compares two numbers to check if the first is greater than the second.
NumberOperationGreaterThan
NumberOperationGreaterThan // >
// NumberOperationGreaterThanOrEqual compares two numbers to check if the first is greater than or equal to the second.
NumberOperationAtMost
NumberOperationAtMost // >=
)
var numberOperations = map[NumberOperation]string{
NumberOperationEqual: " = ",
NumberOperationNotEqual: " <> ",
NumberOperationLessThan: " < ",
NumberOperationAtLeast: " <= ",
NumberOperationGreaterThan: " > ",
NumberOperationAtMost: " >= ",
}
func writeNumberOperation[T Number](builder *StatementBuilder, col Column, op NumberOperation, value T) {
col.WriteQualified(builder)
builder.WriteString(numberOperations[op])
builder.WriteArg(value)
func writeNumberOperation[T Number](builder *StatementBuilder, col Column, op NumberOperation, value any) {
writeOperation[T](builder, col, op.String(), value)
}
type Boolean interface {
~bool
}
// BooleanOperation are operations that can be performed on boolean values.
type BooleanOperation uint8
func writeBooleanOperation[T Boolean](builder *StatementBuilder, col Column, value any) {
writeOperation[T](builder, col, "=", value)
}
type Bytes interface {
~[]byte
}
// BytesOperation are operations that can be performed on bytea values.
type BytesOperation uint8
const (
BooleanOperationIsTrue BooleanOperation = iota + 1
BooleanOperationIsFalse
BytesOperationEqual BytesOperation = iota + 1 // =
BytesOperationNotEqual // <>
)
func writeBooleanOperation[T Boolean](builder *StatementBuilder, col Column, value T) {
func writeBytesOperation[T Bytes](builder *StatementBuilder, col Column, op BytesOperation, value any) {
writeOperation[T](builder, col, op.String(), value)
}
func writeOperation[V Value](builder *StatementBuilder, col Column, op string, value any) {
if op == "" {
panic("unsupported operation")
}
switch value.(type) {
case V, wrappedValue[V], *wrappedValue[V]:
default:
panic("unsupported value type")
}
col.WriteQualified(builder)
builder.WriteString(" = ")
builder.WriteRune(' ')
builder.WriteString(op)
builder.WriteRune(' ')
builder.WriteArg(value)
}