regen ent

2023-01-16 11:34:35 +01:00
parent 1805baedc5
commit f60e8479bc
12 changed files with 575 additions and 1260 deletions
--- a/ent/client.go
+++ b/ent/client.go
@@ -27,7 +27,7 @@ type Client struct {

 // NewClient creates a new client configured with the given options.
 func NewClient(opts ...Option) *Client {
-	cfg := config{log: log.Println, hooks: &hooks{}}
+	cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
 	cfg.options(opts...)
 	client := &Client{config: cfg}
 	client.init()
@@ -122,6 +122,22 @@ func (c *Client) Use(hooks ...Hook) {
 	c.DbPackage.Use(hooks...)
 }

+// Intercept adds the query interceptors to all the entity clients.
+// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
+func (c *Client) Intercept(interceptors ...Interceptor) {
+	c.DbPackage.Intercept(interceptors...)
+}
+
+// Mutate implements the ent.Mutator interface.
+func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
+	switch m := m.(type) {
+	case *DbPackageMutation:
+		return c.DbPackage.mutate(ctx, m)
+	default:
+		return nil, fmt.Errorf("ent: unknown mutation type %T", m)
+	}
+}
+
 // DbPackageClient is a client for the DbPackage schema.
 type DbPackageClient struct {
 	config
@@ -138,6 +154,12 @@ func (c *DbPackageClient) Use(hooks ...Hook) {
 	c.hooks.DbPackage = append(c.hooks.DbPackage, hooks...)
 }

+// Use adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `dbpackage.Intercept(f(g(h())))`.
+func (c *DbPackageClient) Intercept(interceptors ...Interceptor) {
+	c.inters.DbPackage = append(c.inters.DbPackage, interceptors...)
+}
+
 // Create returns a builder for creating a DbPackage entity.
 func (c *DbPackageClient) Create() *DbPackageCreate {
 	mutation := newDbPackageMutation(c.config, OpCreate)
@@ -190,6 +212,7 @@ func (c *DbPackageClient) DeleteOneID(id int) *DbPackageDeleteOne {
 func (c *DbPackageClient) Query() *DbPackageQuery {
 	return &DbPackageQuery{
 		config: c.config,
+		inters: c.Interceptors(),
 	}
 }

@@ -211,3 +234,23 @@ func (c *DbPackageClient) GetX(ctx context.Context, id int) *DbPackage {
 func (c *DbPackageClient) Hooks() []Hook {
 	return c.hooks.DbPackage
 }
+
+// Interceptors returns the client interceptors.
+func (c *DbPackageClient) Interceptors() []Interceptor {
+	return c.inters.DbPackage
+}
+
+func (c *DbPackageClient) mutate(ctx context.Context, m *DbPackageMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&DbPackageCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&DbPackageUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&DbPackageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&DbPackageDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown DbPackage mutation op: %q", m.Op())
+	}
+}
--- a/ent/config.go
+++ b/ent/config.go
@@ -20,12 +20,19 @@ type config struct {
 	log func(...any)
 	// hooks to execute on mutations.
 	hooks *hooks
+	// interceptors to execute on queries.
+	inters *inters
 }

-// hooks per client, for fast access.
-type hooks struct {
-	DbPackage []ent.Hook
-}
+// hooks and interceptors per client, for fast access.
+type (
+	hooks struct {
+		DbPackage []ent.Hook
+	}
+	inters struct {
+		DbPackage []ent.Interceptor
+	}
+)

 // Options applies the options on the config object.
 func (c *config) options(opts ...Option) {
--- a/ent/dbpackage/where.go
+++ b/ent/dbpackage/where.go
--- a/ent/dbpackage_create.go
+++ b/ent/dbpackage_create.go
@@ -317,50 +317,8 @@ func (dpc *DbPackageCreate) Mutation() *DbPackageMutation {

 // Save creates the DbPackage in the database.
 func (dpc *DbPackageCreate) Save(ctx context.Context) (*DbPackage, error) {
-	var (
-		err  error
-		node *DbPackage
-	)
 	dpc.defaults()
-	if len(dpc.hooks) == 0 {
-		if err = dpc.check(); err != nil {
-			return nil, err
-		}
-		node, err = dpc.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*DbPackageMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = dpc.check(); err != nil {
-				return nil, err
-			}
-			dpc.mutation = mutation
-			if node, err = dpc.sqlSave(ctx); err != nil {
-				return nil, err
-			}
-			mutation.id = &node.ID
-			mutation.done = true
-			return node, err
-		})
-		for i := len(dpc.hooks) - 1; i >= 0; i-- {
-			if dpc.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = dpc.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, dpc.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*DbPackage)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from DbPackageMutation", v)
-		}
-		node = nv
-	}
-	return node, err
+	return withHooks[*DbPackage, DbPackageMutation](ctx, dpc.sqlSave, dpc.mutation, dpc.hooks)
 }

 // SaveX calls Save and panics if Save returns an error.
@@ -446,6 +404,9 @@ func (dpc *DbPackageCreate) check() error {
 }

 func (dpc *DbPackageCreate) sqlSave(ctx context.Context) (*DbPackage, error) {
+	if err := dpc.check(); err != nil {
+		return nil, err
+	}
 	_node, _spec := dpc.createSpec()
 	if err := sqlgraph.CreateNode(ctx, dpc.driver, _spec); err != nil {
 		if sqlgraph.IsConstraintError(err) {
@@ -455,6 +416,8 @@ func (dpc *DbPackageCreate) sqlSave(ctx context.Context) (*DbPackage, error) {
 	}
 	id := _spec.ID.Value.(int64)
 	_node.ID = int(id)
+	dpc.mutation.id = &_node.ID
+	dpc.mutation.done = true
 	return _node, nil
 }

--- a/ent/dbpackage_delete.go
+++ b/ent/dbpackage_delete.go
@@ -4,7 +4,6 @@ package ent

 import (
 	"context"
-	"fmt"

 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
@@ -28,34 +27,7 @@ func (dpd *DbPackageDelete) Where(ps ...predicate.DbPackage) *DbPackageDelete {

 // Exec executes the deletion query and returns how many vertices were deleted.
 func (dpd *DbPackageDelete) Exec(ctx context.Context) (int, error) {
-	var (
-		err      error
-		affected int
-	)
-	if len(dpd.hooks) == 0 {
-		affected, err = dpd.sqlExec(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*DbPackageMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			dpd.mutation = mutation
-			affected, err = dpd.sqlExec(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(dpd.hooks) - 1; i >= 0; i-- {
-			if dpd.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = dpd.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, dpd.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
+	return withHooks[int, DbPackageMutation](ctx, dpd.sqlExec, dpd.mutation, dpd.hooks)
 }

 // ExecX is like Exec, but panics if an error occurs.
@@ -88,6 +60,7 @@ func (dpd *DbPackageDelete) sqlExec(ctx context.Context) (int, error) {
 	if err != nil && sqlgraph.IsConstraintError(err) {
 		err = &ConstraintError{msg: err.Error(), wrap: err}
 	}
+	dpd.mutation.done = true
 	return affected, err
 }

--- a/ent/dbpackage_query.go
+++ b/ent/dbpackage_query.go
@@ -22,6 +22,7 @@ type DbPackageQuery struct {
 	unique     *bool
 	order      []OrderFunc
 	fields     []string
+	inters     []Interceptor
 	predicates []predicate.DbPackage
 	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
@@ -35,13 +36,13 @@ func (dpq *DbPackageQuery) Where(ps ...predicate.DbPackage) *DbPackageQuery {
 	return dpq
 }

-// Limit adds a limit step to the query.
+// Limit the number of records to be returned by this query.
 func (dpq *DbPackageQuery) Limit(limit int) *DbPackageQuery {
 	dpq.limit = &limit
 	return dpq
 }

-// Offset adds an offset step to the query.
+// Offset to start from.
 func (dpq *DbPackageQuery) Offset(offset int) *DbPackageQuery {
 	dpq.offset = &offset
 	return dpq
@@ -54,7 +55,7 @@ func (dpq *DbPackageQuery) Unique(unique bool) *DbPackageQuery {
 	return dpq
 }

-// Order adds an order step to the query.
+// Order specifies how the records should be ordered.
 func (dpq *DbPackageQuery) Order(o ...OrderFunc) *DbPackageQuery {
 	dpq.order = append(dpq.order, o...)
 	return dpq
@@ -63,7 +64,7 @@ func (dpq *DbPackageQuery) Order(o ...OrderFunc) *DbPackageQuery {
 // First returns the first DbPackage entity from the query.
 // Returns a *NotFoundError when no DbPackage was found.
 func (dpq *DbPackageQuery) First(ctx context.Context) (*DbPackage, error) {
-	nodes, err := dpq.Limit(1).All(ctx)
+	nodes, err := dpq.Limit(1).All(newQueryContext(ctx, TypeDbPackage, "First"))
 	if err != nil {
 		return nil, err
 	}
@@ -86,7 +87,7 @@ func (dpq *DbPackageQuery) FirstX(ctx context.Context) *DbPackage {
 // Returns a *NotFoundError when no DbPackage ID was found.
 func (dpq *DbPackageQuery) FirstID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = dpq.Limit(1).IDs(ctx); err != nil {
+	if ids, err = dpq.Limit(1).IDs(newQueryContext(ctx, TypeDbPackage, "FirstID")); err != nil {
 		return
 	}
 	if len(ids) == 0 {
@@ -109,7 +110,7 @@ func (dpq *DbPackageQuery) FirstIDX(ctx context.Context) int {
 // Returns a *NotSingularError when more than one DbPackage entity is found.
 // Returns a *NotFoundError when no DbPackage entities are found.
 func (dpq *DbPackageQuery) Only(ctx context.Context) (*DbPackage, error) {
-	nodes, err := dpq.Limit(2).All(ctx)
+	nodes, err := dpq.Limit(2).All(newQueryContext(ctx, TypeDbPackage, "Only"))
 	if err != nil {
 		return nil, err
 	}
@@ -137,7 +138,7 @@ func (dpq *DbPackageQuery) OnlyX(ctx context.Context) *DbPackage {
 // Returns a *NotFoundError when no entities are found.
 func (dpq *DbPackageQuery) OnlyID(ctx context.Context) (id int, err error) {
 	var ids []int
-	if ids, err = dpq.Limit(2).IDs(ctx); err != nil {
+	if ids, err = dpq.Limit(2).IDs(newQueryContext(ctx, TypeDbPackage, "OnlyID")); err != nil {
 		return
 	}
 	switch len(ids) {
@@ -162,10 +163,12 @@ func (dpq *DbPackageQuery) OnlyIDX(ctx context.Context) int {

 // All executes the query and returns a list of DbPackages.
 func (dpq *DbPackageQuery) All(ctx context.Context) ([]*DbPackage, error) {
+	ctx = newQueryContext(ctx, TypeDbPackage, "All")
 	if err := dpq.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	return dpq.sqlAll(ctx)
+	qr := querierAll[[]*DbPackage, *DbPackageQuery]()
+	return withInterceptors[[]*DbPackage](ctx, dpq, qr, dpq.inters)
 }

 // AllX is like All, but panics if an error occurs.
@@ -180,6 +183,7 @@ func (dpq *DbPackageQuery) AllX(ctx context.Context) []*DbPackage {
 // IDs executes the query and returns a list of DbPackage IDs.
 func (dpq *DbPackageQuery) IDs(ctx context.Context) ([]int, error) {
 	var ids []int
+	ctx = newQueryContext(ctx, TypeDbPackage, "IDs")
 	if err := dpq.Select(dbpackage.FieldID).Scan(ctx, &ids); err != nil {
 		return nil, err
 	}
@@ -197,10 +201,11 @@ func (dpq *DbPackageQuery) IDsX(ctx context.Context) []int {

 // Count returns the count of the given query.
 func (dpq *DbPackageQuery) Count(ctx context.Context) (int, error) {
+	ctx = newQueryContext(ctx, TypeDbPackage, "Count")
 	if err := dpq.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return dpq.sqlCount(ctx)
+	return withInterceptors[int](ctx, dpq, querierCount[*DbPackageQuery](), dpq.inters)
 }

 // CountX is like Count, but panics if an error occurs.
@@ -214,10 +219,15 @@ func (dpq *DbPackageQuery) CountX(ctx context.Context) int {

 // Exist returns true if the query has elements in the graph.
 func (dpq *DbPackageQuery) Exist(ctx context.Context) (bool, error) {
-	if err := dpq.prepareQuery(ctx); err != nil {
-		return false, err
+	ctx = newQueryContext(ctx, TypeDbPackage, "Exist")
+	switch _, err := dpq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
 	}
-	return dpq.sqlExist(ctx)
 }

 // ExistX is like Exist, but panics if an error occurs.
@@ -240,6 +250,7 @@ func (dpq *DbPackageQuery) Clone() *DbPackageQuery {
 		limit:      dpq.limit,
 		offset:     dpq.offset,
 		order:      append([]OrderFunc{}, dpq.order...),
+		inters:     append([]Interceptor{}, dpq.inters...),
 		predicates: append([]predicate.DbPackage{}, dpq.predicates...),
 		// clone intermediate query.
 		sql:    dpq.sql.Clone(),
@@ -263,16 +274,11 @@ func (dpq *DbPackageQuery) Clone() *DbPackageQuery {
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
 func (dpq *DbPackageQuery) GroupBy(field string, fields ...string) *DbPackageGroupBy {
-	grbuild := &DbPackageGroupBy{config: dpq.config}
-	grbuild.fields = append([]string{field}, fields...)
-	grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) {
-		if err := dpq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		return dpq.sqlQuery(ctx), nil
-	}
+	dpq.fields = append([]string{field}, fields...)
+	grbuild := &DbPackageGroupBy{build: dpq}
+	grbuild.flds = &dpq.fields
 	grbuild.label = dbpackage.Label
-	grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan
+	grbuild.scan = grbuild.Scan
 	return grbuild
 }

@@ -290,10 +296,10 @@ func (dpq *DbPackageQuery) GroupBy(field string, fields ...string) *DbPackageGro
 //		Scan(ctx, &v)
 func (dpq *DbPackageQuery) Select(fields ...string) *DbPackageSelect {
 	dpq.fields = append(dpq.fields, fields...)
-	selbuild := &DbPackageSelect{DbPackageQuery: dpq}
-	selbuild.label = dbpackage.Label
-	selbuild.flds, selbuild.scan = &dpq.fields, selbuild.Scan
-	return selbuild
+	sbuild := &DbPackageSelect{DbPackageQuery: dpq}
+	sbuild.label = dbpackage.Label
+	sbuild.flds, sbuild.scan = &dpq.fields, sbuild.Scan
+	return sbuild
 }

 // Aggregate returns a DbPackageSelect configured with the given aggregations.
@@ -302,6 +308,16 @@ func (dpq *DbPackageQuery) Aggregate(fns ...AggregateFunc) *DbPackageSelect {
 }

 func (dpq *DbPackageQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range dpq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, dpq); err != nil {
+				return err
+			}
+		}
+	}
 	for _, f := range dpq.fields {
 		if !dbpackage.ValidColumn(f) {
 			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
@@ -357,17 +373,6 @@ func (dpq *DbPackageQuery) sqlCount(ctx context.Context) (int, error) {
 	return sqlgraph.CountNodes(ctx, dpq.driver, _spec)
 }

-func (dpq *DbPackageQuery) sqlExist(ctx context.Context) (bool, error) {
-	switch _, err := dpq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
 func (dpq *DbPackageQuery) querySpec() *sqlgraph.QuerySpec {
 	_spec := &sqlgraph.QuerySpec{
 		Node: &sqlgraph.NodeSpec{
@@ -459,13 +464,8 @@ func (dpq *DbPackageQuery) Modify(modifiers ...func(s *sql.Selector)) *DbPackage

 // DbPackageGroupBy is the group-by builder for DbPackage entities.
 type DbPackageGroupBy struct {
-	config
 	selector
-	fields []string
-	fns    []AggregateFunc
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
+	build *DbPackageQuery
 }

 // Aggregate adds the given aggregation functions to the group-by query.
@@ -474,58 +474,46 @@ func (dpgb *DbPackageGroupBy) Aggregate(fns ...AggregateFunc) *DbPackageGroupBy
 	return dpgb
 }

-// Scan applies the group-by query and scans the result into the given value.
+// Scan applies the selector query and scans the result into the given value.
 func (dpgb *DbPackageGroupBy) Scan(ctx context.Context, v any) error {
-	query, err := dpgb.path(ctx)
-	if err != nil {
+	ctx = newQueryContext(ctx, TypeDbPackage, "GroupBy")
+	if err := dpgb.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	dpgb.sql = query
-	return dpgb.sqlScan(ctx, v)
+	return scanWithInterceptors[*DbPackageQuery, *DbPackageGroupBy](ctx, dpgb.build, dpgb, dpgb.build.inters, v)
 }

-func (dpgb *DbPackageGroupBy) sqlScan(ctx context.Context, v any) error {
-	for _, f := range dpgb.fields {
-		if !dbpackage.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
-		}
+func (dpgb *DbPackageGroupBy) sqlScan(ctx context.Context, root *DbPackageQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(dpgb.fns))
+	for _, fn := range dpgb.fns {
+		aggregation = append(aggregation, fn(selector))
 	}
-	selector := dpgb.sqlQuery()
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*dpgb.flds)+len(dpgb.fns))
+		for _, f := range *dpgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*dpgb.flds...)...)
 	if err := selector.Err(); err != nil {
 		return err
 	}
 	rows := &sql.Rows{}
 	query, args := selector.Query()
-	if err := dpgb.driver.Query(ctx, query, args, rows); err != nil {
+	if err := dpgb.build.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
 	defer rows.Close()
 	return sql.ScanSlice(rows, v)
 }

-func (dpgb *DbPackageGroupBy) sqlQuery() *sql.Selector {
-	selector := dpgb.sql.Select()
-	aggregation := make([]string, 0, len(dpgb.fns))
-	for _, fn := range dpgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(dpgb.fields)+len(dpgb.fns))
-		for _, f := range dpgb.fields {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	return selector.GroupBy(selector.Columns(dpgb.fields...)...)
-}
-
 // DbPackageSelect is the builder for selecting fields of DbPackage entities.
 type DbPackageSelect struct {
 	*DbPackageQuery
 	selector
-	// intermediate query (i.e. traversal path).
-	sql *sql.Selector
 }

 // Aggregate adds the given aggregation functions to the selector query.
@@ -536,26 +524,27 @@ func (dps *DbPackageSelect) Aggregate(fns ...AggregateFunc) *DbPackageSelect {

 // Scan applies the selector query and scans the result into the given value.
 func (dps *DbPackageSelect) Scan(ctx context.Context, v any) error {
+	ctx = newQueryContext(ctx, TypeDbPackage, "Select")
 	if err := dps.prepareQuery(ctx); err != nil {
 		return err
 	}
-	dps.sql = dps.DbPackageQuery.sqlQuery(ctx)
-	return dps.sqlScan(ctx, v)
+	return scanWithInterceptors[*DbPackageQuery, *DbPackageSelect](ctx, dps.DbPackageQuery, dps, dps.inters, v)
 }

-func (dps *DbPackageSelect) sqlScan(ctx context.Context, v any) error {
+func (dps *DbPackageSelect) sqlScan(ctx context.Context, root *DbPackageQuery, v any) error {
+	selector := root.sqlQuery(ctx)
 	aggregation := make([]string, 0, len(dps.fns))
 	for _, fn := range dps.fns {
-		aggregation = append(aggregation, fn(dps.sql))
+		aggregation = append(aggregation, fn(selector))
 	}
 	switch n := len(*dps.selector.flds); {
 	case n == 0 && len(aggregation) > 0:
-		dps.sql.Select(aggregation...)
+		selector.Select(aggregation...)
 	case n != 0 && len(aggregation) > 0:
-		dps.sql.AppendSelect(aggregation...)
+		selector.AppendSelect(aggregation...)
 	}
 	rows := &sql.Rows{}
-	query, args := dps.sql.Query()
+	query, args := selector.Query()
 	if err := dps.driver.Query(ctx, query, args, rows); err != nil {
 		return err
 	}
--- a/ent/dbpackage_update.go
+++ b/ent/dbpackage_update.go
@@ -476,40 +476,7 @@ func (dpu *DbPackageUpdate) Mutation() *DbPackageMutation {

 // Save executes the query and returns the number of nodes affected by the update operation.
 func (dpu *DbPackageUpdate) Save(ctx context.Context) (int, error) {
-	var (
-		err      error
-		affected int
-	)
-	if len(dpu.hooks) == 0 {
-		if err = dpu.check(); err != nil {
-			return 0, err
-		}
-		affected, err = dpu.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*DbPackageMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = dpu.check(); err != nil {
-				return 0, err
-			}
-			dpu.mutation = mutation
-			affected, err = dpu.sqlSave(ctx)
-			mutation.done = true
-			return affected, err
-		})
-		for i := len(dpu.hooks) - 1; i >= 0; i-- {
-			if dpu.hooks[i] == nil {
-				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = dpu.hooks[i](mut)
-		}
-		if _, err := mut.Mutate(ctx, dpu.mutation); err != nil {
-			return 0, err
-		}
-	}
-	return affected, err
+	return withHooks[int, DbPackageMutation](ctx, dpu.sqlSave, dpu.mutation, dpu.hooks)
 }

 // SaveX is like Save, but panics if an error occurs.
@@ -566,6 +533,9 @@ func (dpu *DbPackageUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *DbP
 }

 func (dpu *DbPackageUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := dpu.check(); err != nil {
+		return n, err
+	}
 	_spec := &sqlgraph.UpdateSpec{
 		Node: &sqlgraph.NodeSpec{
 			Table:   dbpackage.Table,
@@ -735,6 +705,7 @@ func (dpu *DbPackageUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		return 0, err
 	}
+	dpu.mutation.done = true
 	return n, nil
 }

@@ -1200,46 +1171,7 @@ func (dpuo *DbPackageUpdateOne) Select(field string, fields ...string) *DbPackag

 // Save executes the query and returns the updated DbPackage entity.
 func (dpuo *DbPackageUpdateOne) Save(ctx context.Context) (*DbPackage, error) {
-	var (
-		err  error
-		node *DbPackage
-	)
-	if len(dpuo.hooks) == 0 {
-		if err = dpuo.check(); err != nil {
-			return nil, err
-		}
-		node, err = dpuo.sqlSave(ctx)
-	} else {
-		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-			mutation, ok := m.(*DbPackageMutation)
-			if !ok {
-				return nil, fmt.Errorf("unexpected mutation type %T", m)
-			}
-			if err = dpuo.check(); err != nil {
-				return nil, err
-			}
-			dpuo.mutation = mutation
-			node, err = dpuo.sqlSave(ctx)
-			mutation.done = true
-			return node, err
-		})
-		for i := len(dpuo.hooks) - 1; i >= 0; i-- {
-			if dpuo.hooks[i] == nil {
-				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-			}
-			mut = dpuo.hooks[i](mut)
-		}
-		v, err := mut.Mutate(ctx, dpuo.mutation)
-		if err != nil {
-			return nil, err
-		}
-		nv, ok := v.(*DbPackage)
-		if !ok {
-			return nil, fmt.Errorf("unexpected node type %T returned from DbPackageMutation", v)
-		}
-		node = nv
-	}
-	return node, err
+	return withHooks[*DbPackage, DbPackageMutation](ctx, dpuo.sqlSave, dpuo.mutation, dpuo.hooks)
 }

 // SaveX is like Save, but panics if an error occurs.
@@ -1296,6 +1228,9 @@ func (dpuo *DbPackageUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder))
 }

 func (dpuo *DbPackageUpdateOne) sqlSave(ctx context.Context) (_node *DbPackage, err error) {
+	if err := dpuo.check(); err != nil {
+		return _node, err
+	}
 	_spec := &sqlgraph.UpdateSpec{
 		Node: &sqlgraph.NodeSpec{
 			Table:   dbpackage.Table,
@@ -1485,5 +1420,6 @@ func (dpuo *DbPackageUpdateOne) sqlSave(ctx context.Context) (_node *DbPackage,
 		}
 		return nil, err
 	}
+	dpuo.mutation.done = true
 	return _node, nil
 }
--- a/ent/ent.go
+++ b/ent/ent.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"reflect"

 	"entgo.io/ent"
 	"entgo.io/ent/dialect/sql"
@@ -15,14 +16,20 @@ import (

 // ent aliases to avoid import conflicts in user's code.
 type (
-	Op         = ent.Op
-	Hook       = ent.Hook
-	Value      = ent.Value
-	Query      = ent.Query
-	Policy     = ent.Policy
-	Mutator    = ent.Mutator
-	Mutation   = ent.Mutation
-	MutateFunc = ent.MutateFunc
+	Op            = ent.Op
+	Hook          = ent.Hook
+	Value         = ent.Value
+	Query         = ent.Query
+	Querier       = ent.Querier
+	QuerierFunc   = ent.QuerierFunc
+	Interceptor   = ent.Interceptor
+	InterceptFunc = ent.InterceptFunc
+	Traverser     = ent.Traverser
+	TraverseFunc  = ent.TraverseFunc
+	Policy        = ent.Policy
+	Mutator       = ent.Mutator
+	Mutation      = ent.Mutation
+	MutateFunc    = ent.MutateFunc
 )

 // OrderFunc applies an ordering on the sql selector.
@@ -462,5 +469,120 @@ func (s *selector) BoolX(ctx context.Context) bool {
 	return v
 }

+// withHooks invokes the builder operation with the given hooks, if any.
+func withHooks[V Value, M any, PM interface {
+	*M
+	Mutation
+}](ctx context.Context, exec func(context.Context) (V, error), mutation PM, hooks []Hook) (value V, err error) {
+	if len(hooks) == 0 {
+		return exec(ctx)
+	}
+	var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+		mutationT, ok := m.(PM)
+		if !ok {
+			return nil, fmt.Errorf("unexpected mutation type %T", m)
+		}
+		// Set the mutation to the builder.
+		*mutation = *mutationT
+		return exec(ctx)
+	})
+	for i := len(hooks) - 1; i >= 0; i-- {
+		if hooks[i] == nil {
+			return value, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
+		}
+		mut = hooks[i](mut)
+	}
+	v, err := mut.Mutate(ctx, mutation)
+	if err != nil {
+		return value, err
+	}
+	nv, ok := v.(V)
+	if !ok {
+		return value, fmt.Errorf("unexpected node type %T returned from %T", v, mutation)
+	}
+	return nv, nil
+}
+
+// newQueryContext returns a new context with the given QueryContext attached in case it does not exist.
+func newQueryContext(ctx context.Context, typ, op string) context.Context {
+	if ent.QueryFromContext(ctx) == nil {
+		ctx = ent.NewQueryContext(ctx, &ent.QueryContext{Type: typ, Op: op})
+	}
+	return ctx
+}
+
+func querierAll[V Value, Q interface {
+	sqlAll(context.Context, ...queryHook) (V, error)
+}]() Querier {
+	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		return query.sqlAll(ctx)
+	})
+}
+
+func querierCount[Q interface {
+	sqlCount(context.Context) (int, error)
+}]() Querier {
+	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		return query.sqlCount(ctx)
+	})
+}
+
+func withInterceptors[V Value](ctx context.Context, q Query, qr Querier, inters []Interceptor) (v V, err error) {
+	for i := len(inters) - 1; i >= 0; i-- {
+		qr = inters[i].Intercept(qr)
+	}
+	rv, err := qr.Query(ctx, q)
+	if err != nil {
+		return v, err
+	}
+	vt, ok := rv.(V)
+	if !ok {
+		return v, fmt.Errorf("unexpected type %T returned from %T. expected type: %T", vt, q, v)
+	}
+	return vt, nil
+}
+
+func scanWithInterceptors[Q1 ent.Query, Q2 interface {
+	sqlScan(context.Context, Q1, any) error
+}](ctx context.Context, rootQuery Q1, selectOrGroup Q2, inters []Interceptor, v any) error {
+	rv := reflect.ValueOf(v)
+	var qr Querier = QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q1)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		if err := selectOrGroup.sqlScan(ctx, query, v); err != nil {
+			return nil, err
+		}
+		if k := rv.Kind(); k == reflect.Pointer && rv.Elem().CanInterface() {
+			return rv.Elem().Interface(), nil
+		}
+		return v, nil
+	})
+	for i := len(inters) - 1; i >= 0; i-- {
+		qr = inters[i].Intercept(qr)
+	}
+	vv, err := qr.Query(ctx, rootQuery)
+	if err != nil {
+		return err
+	}
+	switch rv2 := reflect.ValueOf(vv); {
+	case rv.IsNil(), rv2.IsNil(), rv.Kind() != reflect.Pointer:
+	case rv.Type() == rv2.Type():
+		rv.Elem().Set(rv2.Elem())
+	case rv.Elem().Type() == rv2.Type():
+		rv.Elem().Set(rv2)
+	}
+	return nil
+}
+
 // queryHook describes an internal hook for the different sqlAll methods.
 type queryHook func(context.Context, *sqlgraph.QuerySpec)
--- a/ent/hook/hook.go
+++ b/ent/hook/hook.go
@@ -15,11 +15,10 @@ type DbPackageFunc func(context.Context, *ent.DbPackageMutation) (ent.Value, err

 // Mutate calls f(ctx, m).
 func (f DbPackageFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	mv, ok := m.(*ent.DbPackageMutation)
-	if !ok {
-		return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.DbPackageMutation", m)
+	if mv, ok := m.(*ent.DbPackageMutation); ok {
+		return f(ctx, mv)
 	}
-	return f(ctx, mv)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.DbPackageMutation", m)
 }

 // Condition is a hook condition function.
--- a/ent/mutation.go
+++ b/ent/mutation.go
@@ -13,6 +13,7 @@ import (
 	"git.harting.dev/ALHP/ALHP.GO/ent/predicate"

 	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
 )

 const (
@@ -1380,11 +1381,26 @@ func (m *DbPackageMutation) Where(ps ...predicate.DbPackage) {
 	m.predicates = append(m.predicates, ps...)
 }

+// WhereP appends storage-level predicates to the DbPackageMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *DbPackageMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.DbPackage, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
 // Op returns the operation name.
 func (m *DbPackageMutation) Op() Op {
 	return m.op
 }

+// SetOp allows setting the mutation operation.
+func (m *DbPackageMutation) SetOp(op Op) {
+	m.op = op
+}
+
 // Type returns the node type of this mutation (DbPackage).
 func (m *DbPackageMutation) Type() string {
 	return m.typ
--- a/ent/runtime/runtime.go
+++ b/ent/runtime/runtime.go
@@ -5,6 +5,6 @@ package runtime
 // The schema-stitching logic is generated in git.harting.dev/ALHP/ALHP.GO/ent/runtime.go

 const (
-	Version = "v0.11.4"                                         // Version of ent codegen.
-	Sum     = "h1:grwVY0fp31BZ6oEo3YrXenAuv8VJmEw7F/Bi6WqeH3Q=" // Sum of ent codegen.
+	Version = "v0.11.5"                                         // Version of ent codegen.
+	Sum     = "h1:V2qhG91C4PMQTa82Q4StoESMQ4dzkMNeStCzszxi0jQ=" // Sum of ent codegen.
 )
--- a/go.sum
+++ b/go.sum
@@ -113,9 +113,11 @@ github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope
 github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
 github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/otiai10/copy v1.9.0 h1:7KFNiCgZ91Ru4qW4CWPf/7jqtxLagGRmIxWldPP9VY4=
 github.com/otiai10/copy v1.9.0/go.mod h1:hsfX19wcn0UWIHUQ3/4fHuehhk2UyArQ9dVFAn3FczI=
 github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE=
@@ -142,6 +144,8 @@ github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMB
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
 github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/spf13/cobra v1.6.1 h1:o94oiPyS4KD1mPy2fmcYYHHfCxLqYjJOhGsCHFZtEzA=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
@@ -231,6 +235,7 @@ golang.org/x/tools v0.0.0-20190823170909-c4a336ef6a2f/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.3.1-0.20221202221704-aa9f4b2f3d57 h1:/X0t/E4VxbZE7MLS7auvE7YICHeVvbIa9vkOVvYW/24=
 golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=