mirror of
https://github.com/andwati/zitadel.git
synced 2026-10-27 17:52:14 +00:00
61cab8878e
This PR initiates the rework of Zitadel's backend to state-persisted objects. This change is a step towards a more scalable and maintainable architecture. ## Changes * **New `/backend/v3` package**: A new package structure has been introduced to house the reworked backend logic. This includes: * `domain`: Contains the core business logic, commands, and repository interfaces. * `storage`: Implements the repository interfaces for database interactions with new transactional tables. * `telemetry`: Provides logging and tracing capabilities. * **Transactional Tables**: New database tables have been defined for `instances`, `instance_domains`, `organizations`, and `org_domains`. * **Projections**: New projections have been created to populate the new relational tables from the existing event store, ensuring data consistency during the migration. * **Repositories**: New repositories provide an abstraction layer for accessing and manipulating the data in the new tables. * **Setup**: A new setup step for `TransactionalTables` has been added to manage the database migrations for the new tables. This PR lays the foundation for future work to fully transition to state-persisted objects for these components, which will improve performance and simplify data access patterns. This PR initiates the rework of ZITADEL's backend to state-persisted objects. This is a foundational step towards a new architecture that will improve performance and maintainability. The following objects are migrated from event-sourced aggregates to state-persisted objects: * Instances * incl. Domains * Orgs * incl. Domains The structure of the new backend implementation follows the software architecture defined in this [wiki page](https://github.com/zitadel/zitadel/wiki/Software-Architecturel). This PR includes: * The initial implementation of the new transactional repositories for the objects listed above. * Projections to populate the new relational tables from the existing event store. * Adjustments to the build and test process to accommodate the new backend structure. This is a work in progress and further changes will be made to complete the migration. --------- Co-authored-by: Copilot <[email protected]> Co-authored-by: Iraq Jaber <[email protected]> Co-authored-by: Iraq <[email protected]> Co-authored-by: Tim Möhlmann <[email protected]>
132 lines
3.8 KiB
Go
132 lines
3.8 KiB
Go
package domain
|
|
|
|
// import (
|
|
// "context"
|
|
// "fmt"
|
|
|
|
// "github.com/zitadel/zitadel/backend/v3/storage/database"
|
|
// )
|
|
|
|
// // Commander is the all it needs to implement the command pattern.
|
|
// // It is the interface all manipulations need to implement.
|
|
// // If possible it should also be used for queries. We will find out if this is possible in the future.
|
|
// type Commander interface {
|
|
// Execute(ctx context.Context, opts *CommandOpts) (err error)
|
|
// fmt.Stringer
|
|
// }
|
|
|
|
// // Invoker is part of the command pattern.
|
|
// // It is the interface that is used to execute commands.
|
|
// type Invoker interface {
|
|
// Invoke(ctx context.Context, command Commander, opts *CommandOpts) error
|
|
// }
|
|
|
|
// // CommandOpts are passed to each command
|
|
// // the provide common fields used by commands like the database client.
|
|
// type CommandOpts struct {
|
|
// DB database.QueryExecutor
|
|
// Invoker Invoker
|
|
// }
|
|
|
|
// type ensureTxOpts struct {
|
|
// *database.TransactionOptions
|
|
// }
|
|
|
|
// type EnsureTransactionOpt func(*ensureTxOpts)
|
|
|
|
// // EnsureTx ensures that the DB is a transaction. If it is not, it will start a new transaction.
|
|
// // The returned close function will end the transaction. If the DB is already a transaction, the close function
|
|
// // will do nothing because another [Commander] is already responsible for ending the transaction.
|
|
// func (o *CommandOpts) EnsureTx(ctx context.Context, opts ...EnsureTransactionOpt) (close func(context.Context, error) error, err error) {
|
|
// beginner, ok := o.DB.(database.Beginner)
|
|
// if !ok {
|
|
// // db is already a transaction
|
|
// return func(_ context.Context, err error) error {
|
|
// return err
|
|
// }, nil
|
|
// }
|
|
|
|
// txOpts := &ensureTxOpts{
|
|
// TransactionOptions: new(database.TransactionOptions),
|
|
// }
|
|
// for _, opt := range opts {
|
|
// opt(txOpts)
|
|
// }
|
|
|
|
// tx, err := beginner.Begin(ctx, txOpts.TransactionOptions)
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
// o.DB = tx
|
|
|
|
// return func(ctx context.Context, err error) error {
|
|
// return tx.End(ctx, err)
|
|
// }, nil
|
|
// }
|
|
|
|
// // EnsureClient ensures that the o.DB is a client. If it is not, it will get a new client from the [database.Pool].
|
|
// // The returned close function will release the client. If the o.DB is already a client or transaction, the close function
|
|
// // will do nothing because another [Commander] is already responsible for releasing the client.
|
|
// func (o *CommandOpts) EnsureClient(ctx context.Context) (close func(_ context.Context) error, err error) {
|
|
// pool, ok := o.DB.(database.Pool)
|
|
// if !ok {
|
|
// // o.DB is already a client
|
|
// return func(_ context.Context) error {
|
|
// return nil
|
|
// }, nil
|
|
// }
|
|
// client, err := pool.Acquire(ctx)
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
// o.DB = client
|
|
// return func(ctx context.Context) error {
|
|
// return client.Release(ctx)
|
|
// }, nil
|
|
// }
|
|
|
|
// func (o *CommandOpts) Invoke(ctx context.Context, command Commander) error {
|
|
// if o.Invoker == nil {
|
|
// return command.Execute(ctx, o)
|
|
// }
|
|
// return o.Invoker.Invoke(ctx, command, o)
|
|
// }
|
|
|
|
// func DefaultOpts(invoker Invoker) *CommandOpts {
|
|
// if invoker == nil {
|
|
// invoker = &noopInvoker{}
|
|
// }
|
|
// return &CommandOpts{
|
|
// DB: pool,
|
|
// Invoker: invoker,
|
|
// }
|
|
// }
|
|
|
|
// // commandBatch is a batch of commands.
|
|
// // It uses the [Invoker] provided by the opts to execute each command.
|
|
// type commandBatch struct {
|
|
// Commands []Commander
|
|
// }
|
|
|
|
// func BatchCommands(cmds ...Commander) *commandBatch {
|
|
// return &commandBatch{
|
|
// Commands: cmds,
|
|
// }
|
|
// }
|
|
|
|
// // String implements [Commander].
|
|
// func (cmd *commandBatch) String() string {
|
|
// return "commandBatch"
|
|
// }
|
|
|
|
// func (b *commandBatch) Execute(ctx context.Context, opts *CommandOpts) (err error) {
|
|
// for _, cmd := range b.Commands {
|
|
// if err = opts.Invoke(ctx, cmd); err != nil {
|
|
// return err
|
|
// }
|
|
// }
|
|
// return nil
|
|
// }
|
|
|
|
// var _ Commander = (*commandBatch)(nil)
|