From 04f37f87e2482c75baba0e8fdbc29d04457bd31d Mon Sep 17 00:00:00 2001 From: mikestefanello <552328+mikestefanello@users.noreply.github.com> Date: Fri, 15 Aug 2025 09:58:39 -0400 Subject: [PATCH] Re-generate ent code. --- ent/client.go | 28 +-- ent/ent.go | 4 +- ent/passwordtoken.go | 40 ++-- ent/passwordtoken_create.go | 126 ++++++------- ent/passwordtoken_delete.go | 38 ++-- ent/passwordtoken_query.go | 302 +++++++++++++++---------------- ent/passwordtoken_update.go | 220 +++++++++++----------- ent/runtime/runtime.go | 4 +- ent/user.go | 52 +++--- ent/user_create.go | 196 ++++++++++---------- ent/user_delete.go | 38 ++-- ent/user_query.go | 300 +++++++++++++++--------------- ent/user_update.go | 352 ++++++++++++++++++------------------ 13 files changed, 850 insertions(+), 850 deletions(-) diff --git a/ent/client.go b/ent/client.go index 44d7cd6..126d531 100644 --- a/ent/client.go +++ b/ent/client.go @@ -262,8 +262,8 @@ func (c *PasswordTokenClient) Update() *PasswordTokenUpdate { } // UpdateOne returns an update builder for the given entity. -func (c *PasswordTokenClient) UpdateOne(pt *PasswordToken) *PasswordTokenUpdateOne { - mutation := newPasswordTokenMutation(c.config, OpUpdateOne, withPasswordToken(pt)) +func (c *PasswordTokenClient) UpdateOne(_m *PasswordToken) *PasswordTokenUpdateOne { + mutation := newPasswordTokenMutation(c.config, OpUpdateOne, withPasswordToken(_m)) return &PasswordTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} } @@ -280,8 +280,8 @@ func (c *PasswordTokenClient) Delete() *PasswordTokenDelete { } // DeleteOne returns a builder for deleting the given entity. -func (c *PasswordTokenClient) DeleteOne(pt *PasswordToken) *PasswordTokenDeleteOne { - return c.DeleteOneID(pt.ID) +func (c *PasswordTokenClient) DeleteOne(_m *PasswordToken) *PasswordTokenDeleteOne { + return c.DeleteOneID(_m.ID) } // DeleteOneID returns a builder for deleting the given entity by its id. @@ -316,16 +316,16 @@ func (c *PasswordTokenClient) GetX(ctx context.Context, id int) *PasswordToken { } // QueryUser queries the user edge of a PasswordToken. -func (c *PasswordTokenClient) QueryUser(pt *PasswordToken) *UserQuery { +func (c *PasswordTokenClient) QueryUser(_m *PasswordToken) *UserQuery { query := (&UserClient{config: c.config}).Query() query.path = func(context.Context) (fromV *sql.Selector, _ error) { - id := pt.ID + id := _m.ID step := sqlgraph.NewStep( sqlgraph.From(passwordtoken.Table, passwordtoken.FieldID, id), sqlgraph.To(user.Table, user.FieldID), sqlgraph.Edge(sqlgraph.M2O, false, passwordtoken.UserTable, passwordtoken.UserColumn), ) - fromV = sqlgraph.Neighbors(pt.driver.Dialect(), step) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) return fromV, nil } return query @@ -412,8 +412,8 @@ func (c *UserClient) Update() *UserUpdate { } // UpdateOne returns an update builder for the given entity. -func (c *UserClient) UpdateOne(u *User) *UserUpdateOne { - mutation := newUserMutation(c.config, OpUpdateOne, withUser(u)) +func (c *UserClient) UpdateOne(_m *User) *UserUpdateOne { + mutation := newUserMutation(c.config, OpUpdateOne, withUser(_m)) return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} } @@ -430,8 +430,8 @@ func (c *UserClient) Delete() *UserDelete { } // DeleteOne returns a builder for deleting the given entity. -func (c *UserClient) DeleteOne(u *User) *UserDeleteOne { - return c.DeleteOneID(u.ID) +func (c *UserClient) DeleteOne(_m *User) *UserDeleteOne { + return c.DeleteOneID(_m.ID) } // DeleteOneID returns a builder for deleting the given entity by its id. @@ -466,16 +466,16 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { } // QueryOwner queries the owner edge of a User. -func (c *UserClient) QueryOwner(u *User) *PasswordTokenQuery { +func (c *UserClient) QueryOwner(_m *User) *PasswordTokenQuery { query := (&PasswordTokenClient{config: c.config}).Query() query.path = func(context.Context) (fromV *sql.Selector, _ error) { - id := u.ID + id := _m.ID step := sqlgraph.NewStep( sqlgraph.From(user.Table, user.FieldID, id), sqlgraph.To(passwordtoken.Table, passwordtoken.FieldID), sqlgraph.Edge(sqlgraph.O2M, true, user.OwnerTable, user.OwnerColumn), ) - fromV = sqlgraph.Neighbors(u.driver.Dialect(), step) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) return fromV, nil } return query diff --git a/ent/ent.go b/ent/ent.go index 9430079..ff6dafb 100644 --- a/ent/ent.go +++ b/ent/ent.go @@ -71,14 +71,14 @@ var ( ) // checkColumn checks if the column exists in the given table. -func checkColumn(table, column string) error { +func checkColumn(t, c string) error { initCheck.Do(func() { columnCheck = sql.NewColumnCheck(map[string]func(string) bool{ passwordtoken.Table: passwordtoken.ValidColumn, user.Table: user.ValidColumn, }) }) - return columnCheck(table, column) + return columnCheck(t, c) } // Asc applies the given fields in ASC order. diff --git a/ent/passwordtoken.go b/ent/passwordtoken.go index e7af3e2..fec22ac 100644 --- a/ent/passwordtoken.go +++ b/ent/passwordtoken.go @@ -70,7 +70,7 @@ func (*PasswordToken) scanValues(columns []string) ([]any, error) { // assignValues assigns the values that were returned from sql.Rows (after scanning) // to the PasswordToken fields. -func (pt *PasswordToken) assignValues(columns []string, values []any) error { +func (_m *PasswordToken) assignValues(columns []string, values []any) error { if m, n := len(values), len(columns); m < n { return fmt.Errorf("mismatch number of scan values: %d != %d", m, n) } @@ -81,27 +81,27 @@ func (pt *PasswordToken) assignValues(columns []string, values []any) error { if !ok { return fmt.Errorf("unexpected type %T for field id", value) } - pt.ID = int(value.Int64) + _m.ID = int(value.Int64) case passwordtoken.FieldToken: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field token", values[i]) } else if value.Valid { - pt.Token = value.String + _m.Token = value.String } case passwordtoken.FieldUserID: if value, ok := values[i].(*sql.NullInt64); !ok { return fmt.Errorf("unexpected type %T for field user_id", values[i]) } else if value.Valid { - pt.UserID = int(value.Int64) + _m.UserID = int(value.Int64) } case passwordtoken.FieldCreatedAt: if value, ok := values[i].(*sql.NullTime); !ok { return fmt.Errorf("unexpected type %T for field created_at", values[i]) } else if value.Valid { - pt.CreatedAt = value.Time + _m.CreatedAt = value.Time } default: - pt.selectValues.Set(columns[i], values[i]) + _m.selectValues.Set(columns[i], values[i]) } } return nil @@ -109,45 +109,45 @@ func (pt *PasswordToken) assignValues(columns []string, values []any) error { // Value returns the ent.Value that was dynamically selected and assigned to the PasswordToken. // This includes values selected through modifiers, order, etc. -func (pt *PasswordToken) Value(name string) (ent.Value, error) { - return pt.selectValues.Get(name) +func (_m *PasswordToken) Value(name string) (ent.Value, error) { + return _m.selectValues.Get(name) } // QueryUser queries the "user" edge of the PasswordToken entity. -func (pt *PasswordToken) QueryUser() *UserQuery { - return NewPasswordTokenClient(pt.config).QueryUser(pt) +func (_m *PasswordToken) QueryUser() *UserQuery { + return NewPasswordTokenClient(_m.config).QueryUser(_m) } // Update returns a builder for updating this PasswordToken. // Note that you need to call PasswordToken.Unwrap() before calling this method if this PasswordToken // was returned from a transaction, and the transaction was committed or rolled back. -func (pt *PasswordToken) Update() *PasswordTokenUpdateOne { - return NewPasswordTokenClient(pt.config).UpdateOne(pt) +func (_m *PasswordToken) Update() *PasswordTokenUpdateOne { + return NewPasswordTokenClient(_m.config).UpdateOne(_m) } // Unwrap unwraps the PasswordToken entity that was returned from a transaction after it was closed, // so that all future queries will be executed through the driver which created the transaction. -func (pt *PasswordToken) Unwrap() *PasswordToken { - _tx, ok := pt.config.driver.(*txDriver) +func (_m *PasswordToken) Unwrap() *PasswordToken { + _tx, ok := _m.config.driver.(*txDriver) if !ok { panic("ent: PasswordToken is not a transactional entity") } - pt.config.driver = _tx.drv - return pt + _m.config.driver = _tx.drv + return _m } // String implements the fmt.Stringer. -func (pt *PasswordToken) String() string { +func (_m *PasswordToken) String() string { var builder strings.Builder builder.WriteString("PasswordToken(") - builder.WriteString(fmt.Sprintf("id=%v, ", pt.ID)) + builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID)) builder.WriteString("token=") builder.WriteString(", ") builder.WriteString("user_id=") - builder.WriteString(fmt.Sprintf("%v", pt.UserID)) + builder.WriteString(fmt.Sprintf("%v", _m.UserID)) builder.WriteString(", ") builder.WriteString("created_at=") - builder.WriteString(pt.CreatedAt.Format(time.ANSIC)) + builder.WriteString(_m.CreatedAt.Format(time.ANSIC)) builder.WriteByte(')') return builder.String() } diff --git a/ent/passwordtoken_create.go b/ent/passwordtoken_create.go index 60374a9..e5bb2dd 100644 --- a/ent/passwordtoken_create.go +++ b/ent/passwordtoken_create.go @@ -22,52 +22,52 @@ type PasswordTokenCreate struct { } // SetToken sets the "token" field. -func (ptc *PasswordTokenCreate) SetToken(s string) *PasswordTokenCreate { - ptc.mutation.SetToken(s) - return ptc +func (_c *PasswordTokenCreate) SetToken(v string) *PasswordTokenCreate { + _c.mutation.SetToken(v) + return _c } // SetUserID sets the "user_id" field. -func (ptc *PasswordTokenCreate) SetUserID(i int) *PasswordTokenCreate { - ptc.mutation.SetUserID(i) - return ptc +func (_c *PasswordTokenCreate) SetUserID(v int) *PasswordTokenCreate { + _c.mutation.SetUserID(v) + return _c } // SetCreatedAt sets the "created_at" field. -func (ptc *PasswordTokenCreate) SetCreatedAt(t time.Time) *PasswordTokenCreate { - ptc.mutation.SetCreatedAt(t) - return ptc +func (_c *PasswordTokenCreate) SetCreatedAt(v time.Time) *PasswordTokenCreate { + _c.mutation.SetCreatedAt(v) + return _c } // SetNillableCreatedAt sets the "created_at" field if the given value is not nil. -func (ptc *PasswordTokenCreate) SetNillableCreatedAt(t *time.Time) *PasswordTokenCreate { - if t != nil { - ptc.SetCreatedAt(*t) +func (_c *PasswordTokenCreate) SetNillableCreatedAt(v *time.Time) *PasswordTokenCreate { + if v != nil { + _c.SetCreatedAt(*v) } - return ptc + return _c } // SetUser sets the "user" edge to the User entity. -func (ptc *PasswordTokenCreate) SetUser(u *User) *PasswordTokenCreate { - return ptc.SetUserID(u.ID) +func (_c *PasswordTokenCreate) SetUser(v *User) *PasswordTokenCreate { + return _c.SetUserID(v.ID) } // Mutation returns the PasswordTokenMutation object of the builder. -func (ptc *PasswordTokenCreate) Mutation() *PasswordTokenMutation { - return ptc.mutation +func (_c *PasswordTokenCreate) Mutation() *PasswordTokenMutation { + return _c.mutation } // Save creates the PasswordToken in the database. -func (ptc *PasswordTokenCreate) Save(ctx context.Context) (*PasswordToken, error) { - if err := ptc.defaults(); err != nil { +func (_c *PasswordTokenCreate) Save(ctx context.Context) (*PasswordToken, error) { + if err := _c.defaults(); err != nil { return nil, err } - return withHooks(ctx, ptc.sqlSave, ptc.mutation, ptc.hooks) + return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks) } // SaveX calls Save and panics if Save returns an error. -func (ptc *PasswordTokenCreate) SaveX(ctx context.Context) *PasswordToken { - v, err := ptc.Save(ctx) +func (_c *PasswordTokenCreate) SaveX(ctx context.Context) *PasswordToken { + v, err := _c.Save(ctx) if err != nil { panic(err) } @@ -75,58 +75,58 @@ func (ptc *PasswordTokenCreate) SaveX(ctx context.Context) *PasswordToken { } // Exec executes the query. -func (ptc *PasswordTokenCreate) Exec(ctx context.Context) error { - _, err := ptc.Save(ctx) +func (_c *PasswordTokenCreate) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (ptc *PasswordTokenCreate) ExecX(ctx context.Context) { - if err := ptc.Exec(ctx); err != nil { +func (_c *PasswordTokenCreate) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { panic(err) } } // defaults sets the default values of the builder before save. -func (ptc *PasswordTokenCreate) defaults() error { - if _, ok := ptc.mutation.CreatedAt(); !ok { +func (_c *PasswordTokenCreate) defaults() error { + if _, ok := _c.mutation.CreatedAt(); !ok { if passwordtoken.DefaultCreatedAt == nil { return fmt.Errorf("ent: uninitialized passwordtoken.DefaultCreatedAt (forgotten import ent/runtime?)") } v := passwordtoken.DefaultCreatedAt() - ptc.mutation.SetCreatedAt(v) + _c.mutation.SetCreatedAt(v) } return nil } // check runs all checks and user-defined validators on the builder. -func (ptc *PasswordTokenCreate) check() error { - if _, ok := ptc.mutation.Token(); !ok { +func (_c *PasswordTokenCreate) check() error { + if _, ok := _c.mutation.Token(); !ok { return &ValidationError{Name: "token", err: errors.New(`ent: missing required field "PasswordToken.token"`)} } - if v, ok := ptc.mutation.Token(); ok { + if v, ok := _c.mutation.Token(); ok { if err := passwordtoken.TokenValidator(v); err != nil { return &ValidationError{Name: "token", err: fmt.Errorf(`ent: validator failed for field "PasswordToken.token": %w`, err)} } } - if _, ok := ptc.mutation.UserID(); !ok { + if _, ok := _c.mutation.UserID(); !ok { return &ValidationError{Name: "user_id", err: errors.New(`ent: missing required field "PasswordToken.user_id"`)} } - if _, ok := ptc.mutation.CreatedAt(); !ok { + if _, ok := _c.mutation.CreatedAt(); !ok { return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "PasswordToken.created_at"`)} } - if len(ptc.mutation.UserIDs()) == 0 { + if len(_c.mutation.UserIDs()) == 0 { return &ValidationError{Name: "user", err: errors.New(`ent: missing required edge "PasswordToken.user"`)} } return nil } -func (ptc *PasswordTokenCreate) sqlSave(ctx context.Context) (*PasswordToken, error) { - if err := ptc.check(); err != nil { +func (_c *PasswordTokenCreate) sqlSave(ctx context.Context) (*PasswordToken, error) { + if err := _c.check(); err != nil { return nil, err } - _node, _spec := ptc.createSpec() - if err := sqlgraph.CreateNode(ctx, ptc.driver, _spec); err != nil { + _node, _spec := _c.createSpec() + if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil { if sqlgraph.IsConstraintError(err) { err = &ConstraintError{msg: err.Error(), wrap: err} } @@ -134,25 +134,25 @@ func (ptc *PasswordTokenCreate) sqlSave(ctx context.Context) (*PasswordToken, er } id := _spec.ID.Value.(int64) _node.ID = int(id) - ptc.mutation.id = &_node.ID - ptc.mutation.done = true + _c.mutation.id = &_node.ID + _c.mutation.done = true return _node, nil } -func (ptc *PasswordTokenCreate) createSpec() (*PasswordToken, *sqlgraph.CreateSpec) { +func (_c *PasswordTokenCreate) createSpec() (*PasswordToken, *sqlgraph.CreateSpec) { var ( - _node = &PasswordToken{config: ptc.config} + _node = &PasswordToken{config: _c.config} _spec = sqlgraph.NewCreateSpec(passwordtoken.Table, sqlgraph.NewFieldSpec(passwordtoken.FieldID, field.TypeInt)) ) - if value, ok := ptc.mutation.Token(); ok { + if value, ok := _c.mutation.Token(); ok { _spec.SetField(passwordtoken.FieldToken, field.TypeString, value) _node.Token = value } - if value, ok := ptc.mutation.CreatedAt(); ok { + if value, ok := _c.mutation.CreatedAt(); ok { _spec.SetField(passwordtoken.FieldCreatedAt, field.TypeTime, value) _node.CreatedAt = value } - if nodes := ptc.mutation.UserIDs(); len(nodes) > 0 { + if nodes := _c.mutation.UserIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.M2O, Inverse: false, @@ -180,16 +180,16 @@ type PasswordTokenCreateBulk struct { } // Save creates the PasswordToken entities in the database. -func (ptcb *PasswordTokenCreateBulk) Save(ctx context.Context) ([]*PasswordToken, error) { - if ptcb.err != nil { - return nil, ptcb.err +func (_c *PasswordTokenCreateBulk) Save(ctx context.Context) ([]*PasswordToken, error) { + if _c.err != nil { + return nil, _c.err } - specs := make([]*sqlgraph.CreateSpec, len(ptcb.builders)) - nodes := make([]*PasswordToken, len(ptcb.builders)) - mutators := make([]Mutator, len(ptcb.builders)) - for i := range ptcb.builders { + specs := make([]*sqlgraph.CreateSpec, len(_c.builders)) + nodes := make([]*PasswordToken, len(_c.builders)) + mutators := make([]Mutator, len(_c.builders)) + for i := range _c.builders { func(i int, root context.Context) { - builder := ptcb.builders[i] + builder := _c.builders[i] builder.defaults() var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { mutation, ok := m.(*PasswordTokenMutation) @@ -203,11 +203,11 @@ func (ptcb *PasswordTokenCreateBulk) Save(ctx context.Context) ([]*PasswordToken var err error nodes[i], specs[i] = builder.createSpec() if i < len(mutators)-1 { - _, err = mutators[i+1].Mutate(root, ptcb.builders[i+1].mutation) + _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation) } else { spec := &sqlgraph.BatchCreateSpec{Nodes: specs} // Invoke the actual operation on the latest mutation in the chain. - if err = sqlgraph.BatchCreate(ctx, ptcb.driver, spec); err != nil { + if err = sqlgraph.BatchCreate(ctx, _c.driver, spec); err != nil { if sqlgraph.IsConstraintError(err) { err = &ConstraintError{msg: err.Error(), wrap: err} } @@ -231,7 +231,7 @@ func (ptcb *PasswordTokenCreateBulk) Save(ctx context.Context) ([]*PasswordToken }(i, ctx) } if len(mutators) > 0 { - if _, err := mutators[0].Mutate(ctx, ptcb.builders[0].mutation); err != nil { + if _, err := mutators[0].Mutate(ctx, _c.builders[0].mutation); err != nil { return nil, err } } @@ -239,8 +239,8 @@ func (ptcb *PasswordTokenCreateBulk) Save(ctx context.Context) ([]*PasswordToken } // SaveX is like Save, but panics if an error occurs. -func (ptcb *PasswordTokenCreateBulk) SaveX(ctx context.Context) []*PasswordToken { - v, err := ptcb.Save(ctx) +func (_c *PasswordTokenCreateBulk) SaveX(ctx context.Context) []*PasswordToken { + v, err := _c.Save(ctx) if err != nil { panic(err) } @@ -248,14 +248,14 @@ func (ptcb *PasswordTokenCreateBulk) SaveX(ctx context.Context) []*PasswordToken } // Exec executes the query. -func (ptcb *PasswordTokenCreateBulk) Exec(ctx context.Context) error { - _, err := ptcb.Save(ctx) +func (_c *PasswordTokenCreateBulk) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (ptcb *PasswordTokenCreateBulk) ExecX(ctx context.Context) { - if err := ptcb.Exec(ctx); err != nil { +func (_c *PasswordTokenCreateBulk) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { panic(err) } } diff --git a/ent/passwordtoken_delete.go b/ent/passwordtoken_delete.go index c18bbf7..252f195 100644 --- a/ent/passwordtoken_delete.go +++ b/ent/passwordtoken_delete.go @@ -20,56 +20,56 @@ type PasswordTokenDelete struct { } // Where appends a list predicates to the PasswordTokenDelete builder. -func (ptd *PasswordTokenDelete) Where(ps ...predicate.PasswordToken) *PasswordTokenDelete { - ptd.mutation.Where(ps...) - return ptd +func (_d *PasswordTokenDelete) Where(ps ...predicate.PasswordToken) *PasswordTokenDelete { + _d.mutation.Where(ps...) + return _d } // Exec executes the deletion query and returns how many vertices were deleted. -func (ptd *PasswordTokenDelete) Exec(ctx context.Context) (int, error) { - return withHooks(ctx, ptd.sqlExec, ptd.mutation, ptd.hooks) +func (_d *PasswordTokenDelete) Exec(ctx context.Context) (int, error) { + return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks) } // ExecX is like Exec, but panics if an error occurs. -func (ptd *PasswordTokenDelete) ExecX(ctx context.Context) int { - n, err := ptd.Exec(ctx) +func (_d *PasswordTokenDelete) ExecX(ctx context.Context) int { + n, err := _d.Exec(ctx) if err != nil { panic(err) } return n } -func (ptd *PasswordTokenDelete) sqlExec(ctx context.Context) (int, error) { +func (_d *PasswordTokenDelete) sqlExec(ctx context.Context) (int, error) { _spec := sqlgraph.NewDeleteSpec(passwordtoken.Table, sqlgraph.NewFieldSpec(passwordtoken.FieldID, field.TypeInt)) - if ps := ptd.mutation.predicates; len(ps) > 0 { + if ps := _d.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - affected, err := sqlgraph.DeleteNodes(ctx, ptd.driver, _spec) + affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec) if err != nil && sqlgraph.IsConstraintError(err) { err = &ConstraintError{msg: err.Error(), wrap: err} } - ptd.mutation.done = true + _d.mutation.done = true return affected, err } // PasswordTokenDeleteOne is the builder for deleting a single PasswordToken entity. type PasswordTokenDeleteOne struct { - ptd *PasswordTokenDelete + _d *PasswordTokenDelete } // Where appends a list predicates to the PasswordTokenDelete builder. -func (ptdo *PasswordTokenDeleteOne) Where(ps ...predicate.PasswordToken) *PasswordTokenDeleteOne { - ptdo.ptd.mutation.Where(ps...) - return ptdo +func (_d *PasswordTokenDeleteOne) Where(ps ...predicate.PasswordToken) *PasswordTokenDeleteOne { + _d._d.mutation.Where(ps...) + return _d } // Exec executes the deletion query. -func (ptdo *PasswordTokenDeleteOne) Exec(ctx context.Context) error { - n, err := ptdo.ptd.Exec(ctx) +func (_d *PasswordTokenDeleteOne) Exec(ctx context.Context) error { + n, err := _d._d.Exec(ctx) switch { case err != nil: return err @@ -81,8 +81,8 @@ func (ptdo *PasswordTokenDeleteOne) Exec(ctx context.Context) error { } // ExecX is like Exec, but panics if an error occurs. -func (ptdo *PasswordTokenDeleteOne) ExecX(ctx context.Context) { - if err := ptdo.Exec(ctx); err != nil { +func (_d *PasswordTokenDeleteOne) ExecX(ctx context.Context) { + if err := _d.Exec(ctx); err != nil { panic(err) } } diff --git a/ent/passwordtoken_query.go b/ent/passwordtoken_query.go index 67ce16d..8168b61 100644 --- a/ent/passwordtoken_query.go +++ b/ent/passwordtoken_query.go @@ -30,44 +30,44 @@ type PasswordTokenQuery struct { } // Where adds a new predicate for the PasswordTokenQuery builder. -func (ptq *PasswordTokenQuery) Where(ps ...predicate.PasswordToken) *PasswordTokenQuery { - ptq.predicates = append(ptq.predicates, ps...) - return ptq +func (_q *PasswordTokenQuery) Where(ps ...predicate.PasswordToken) *PasswordTokenQuery { + _q.predicates = append(_q.predicates, ps...) + return _q } // Limit the number of records to be returned by this query. -func (ptq *PasswordTokenQuery) Limit(limit int) *PasswordTokenQuery { - ptq.ctx.Limit = &limit - return ptq +func (_q *PasswordTokenQuery) Limit(limit int) *PasswordTokenQuery { + _q.ctx.Limit = &limit + return _q } // Offset to start from. -func (ptq *PasswordTokenQuery) Offset(offset int) *PasswordTokenQuery { - ptq.ctx.Offset = &offset - return ptq +func (_q *PasswordTokenQuery) Offset(offset int) *PasswordTokenQuery { + _q.ctx.Offset = &offset + return _q } // Unique configures the query builder to filter duplicate records on query. // By default, unique is set to true, and can be disabled using this method. -func (ptq *PasswordTokenQuery) Unique(unique bool) *PasswordTokenQuery { - ptq.ctx.Unique = &unique - return ptq +func (_q *PasswordTokenQuery) Unique(unique bool) *PasswordTokenQuery { + _q.ctx.Unique = &unique + return _q } // Order specifies how the records should be ordered. -func (ptq *PasswordTokenQuery) Order(o ...passwordtoken.OrderOption) *PasswordTokenQuery { - ptq.order = append(ptq.order, o...) - return ptq +func (_q *PasswordTokenQuery) Order(o ...passwordtoken.OrderOption) *PasswordTokenQuery { + _q.order = append(_q.order, o...) + return _q } // QueryUser chains the current query on the "user" edge. -func (ptq *PasswordTokenQuery) QueryUser() *UserQuery { - query := (&UserClient{config: ptq.config}).Query() +func (_q *PasswordTokenQuery) QueryUser() *UserQuery { + query := (&UserClient{config: _q.config}).Query() query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { - if err := ptq.prepareQuery(ctx); err != nil { + if err := _q.prepareQuery(ctx); err != nil { return nil, err } - selector := ptq.sqlQuery(ctx) + selector := _q.sqlQuery(ctx) if err := selector.Err(); err != nil { return nil, err } @@ -76,7 +76,7 @@ func (ptq *PasswordTokenQuery) QueryUser() *UserQuery { sqlgraph.To(user.Table, user.FieldID), sqlgraph.Edge(sqlgraph.M2O, false, passwordtoken.UserTable, passwordtoken.UserColumn), ) - fromU = sqlgraph.SetNeighbors(ptq.driver.Dialect(), step) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) return fromU, nil } return query @@ -84,8 +84,8 @@ func (ptq *PasswordTokenQuery) QueryUser() *UserQuery { // First returns the first PasswordToken entity from the query. // Returns a *NotFoundError when no PasswordToken was found. -func (ptq *PasswordTokenQuery) First(ctx context.Context) (*PasswordToken, error) { - nodes, err := ptq.Limit(1).All(setContextOp(ctx, ptq.ctx, ent.OpQueryFirst)) +func (_q *PasswordTokenQuery) First(ctx context.Context) (*PasswordToken, error) { + nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst)) if err != nil { return nil, err } @@ -96,8 +96,8 @@ func (ptq *PasswordTokenQuery) First(ctx context.Context) (*PasswordToken, error } // FirstX is like First, but panics if an error occurs. -func (ptq *PasswordTokenQuery) FirstX(ctx context.Context) *PasswordToken { - node, err := ptq.First(ctx) +func (_q *PasswordTokenQuery) FirstX(ctx context.Context) *PasswordToken { + node, err := _q.First(ctx) if err != nil && !IsNotFound(err) { panic(err) } @@ -106,9 +106,9 @@ func (ptq *PasswordTokenQuery) FirstX(ctx context.Context) *PasswordToken { // FirstID returns the first PasswordToken ID from the query. // Returns a *NotFoundError when no PasswordToken ID was found. -func (ptq *PasswordTokenQuery) FirstID(ctx context.Context) (id int, err error) { +func (_q *PasswordTokenQuery) FirstID(ctx context.Context) (id int, err error) { var ids []int - if ids, err = ptq.Limit(1).IDs(setContextOp(ctx, ptq.ctx, ent.OpQueryFirstID)); err != nil { + if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil { return } if len(ids) == 0 { @@ -119,8 +119,8 @@ func (ptq *PasswordTokenQuery) FirstID(ctx context.Context) (id int, err error) } // FirstIDX is like FirstID, but panics if an error occurs. -func (ptq *PasswordTokenQuery) FirstIDX(ctx context.Context) int { - id, err := ptq.FirstID(ctx) +func (_q *PasswordTokenQuery) FirstIDX(ctx context.Context) int { + id, err := _q.FirstID(ctx) if err != nil && !IsNotFound(err) { panic(err) } @@ -130,8 +130,8 @@ func (ptq *PasswordTokenQuery) FirstIDX(ctx context.Context) int { // Only returns a single PasswordToken entity found by the query, ensuring it only returns one. // Returns a *NotSingularError when more than one PasswordToken entity is found. // Returns a *NotFoundError when no PasswordToken entities are found. -func (ptq *PasswordTokenQuery) Only(ctx context.Context) (*PasswordToken, error) { - nodes, err := ptq.Limit(2).All(setContextOp(ctx, ptq.ctx, ent.OpQueryOnly)) +func (_q *PasswordTokenQuery) Only(ctx context.Context) (*PasswordToken, error) { + nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly)) if err != nil { return nil, err } @@ -146,8 +146,8 @@ func (ptq *PasswordTokenQuery) Only(ctx context.Context) (*PasswordToken, error) } // OnlyX is like Only, but panics if an error occurs. -func (ptq *PasswordTokenQuery) OnlyX(ctx context.Context) *PasswordToken { - node, err := ptq.Only(ctx) +func (_q *PasswordTokenQuery) OnlyX(ctx context.Context) *PasswordToken { + node, err := _q.Only(ctx) if err != nil { panic(err) } @@ -157,9 +157,9 @@ func (ptq *PasswordTokenQuery) OnlyX(ctx context.Context) *PasswordToken { // OnlyID is like Only, but returns the only PasswordToken ID in the query. // Returns a *NotSingularError when more than one PasswordToken ID is found. // Returns a *NotFoundError when no entities are found. -func (ptq *PasswordTokenQuery) OnlyID(ctx context.Context) (id int, err error) { +func (_q *PasswordTokenQuery) OnlyID(ctx context.Context) (id int, err error) { var ids []int - if ids, err = ptq.Limit(2).IDs(setContextOp(ctx, ptq.ctx, ent.OpQueryOnlyID)); err != nil { + if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil { return } switch len(ids) { @@ -174,8 +174,8 @@ func (ptq *PasswordTokenQuery) OnlyID(ctx context.Context) (id int, err error) { } // OnlyIDX is like OnlyID, but panics if an error occurs. -func (ptq *PasswordTokenQuery) OnlyIDX(ctx context.Context) int { - id, err := ptq.OnlyID(ctx) +func (_q *PasswordTokenQuery) OnlyIDX(ctx context.Context) int { + id, err := _q.OnlyID(ctx) if err != nil { panic(err) } @@ -183,18 +183,18 @@ func (ptq *PasswordTokenQuery) OnlyIDX(ctx context.Context) int { } // All executes the query and returns a list of PasswordTokens. -func (ptq *PasswordTokenQuery) All(ctx context.Context) ([]*PasswordToken, error) { - ctx = setContextOp(ctx, ptq.ctx, ent.OpQueryAll) - if err := ptq.prepareQuery(ctx); err != nil { +func (_q *PasswordTokenQuery) All(ctx context.Context) ([]*PasswordToken, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll) + if err := _q.prepareQuery(ctx); err != nil { return nil, err } qr := querierAll[[]*PasswordToken, *PasswordTokenQuery]() - return withInterceptors[[]*PasswordToken](ctx, ptq, qr, ptq.inters) + return withInterceptors[[]*PasswordToken](ctx, _q, qr, _q.inters) } // AllX is like All, but panics if an error occurs. -func (ptq *PasswordTokenQuery) AllX(ctx context.Context) []*PasswordToken { - nodes, err := ptq.All(ctx) +func (_q *PasswordTokenQuery) AllX(ctx context.Context) []*PasswordToken { + nodes, err := _q.All(ctx) if err != nil { panic(err) } @@ -202,20 +202,20 @@ func (ptq *PasswordTokenQuery) AllX(ctx context.Context) []*PasswordToken { } // IDs executes the query and returns a list of PasswordToken IDs. -func (ptq *PasswordTokenQuery) IDs(ctx context.Context) (ids []int, err error) { - if ptq.ctx.Unique == nil && ptq.path != nil { - ptq.Unique(true) +func (_q *PasswordTokenQuery) IDs(ctx context.Context) (ids []int, err error) { + if _q.ctx.Unique == nil && _q.path != nil { + _q.Unique(true) } - ctx = setContextOp(ctx, ptq.ctx, ent.OpQueryIDs) - if err = ptq.Select(passwordtoken.FieldID).Scan(ctx, &ids); err != nil { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs) + if err = _q.Select(passwordtoken.FieldID).Scan(ctx, &ids); err != nil { return nil, err } return ids, nil } // IDsX is like IDs, but panics if an error occurs. -func (ptq *PasswordTokenQuery) IDsX(ctx context.Context) []int { - ids, err := ptq.IDs(ctx) +func (_q *PasswordTokenQuery) IDsX(ctx context.Context) []int { + ids, err := _q.IDs(ctx) if err != nil { panic(err) } @@ -223,17 +223,17 @@ func (ptq *PasswordTokenQuery) IDsX(ctx context.Context) []int { } // Count returns the count of the given query. -func (ptq *PasswordTokenQuery) Count(ctx context.Context) (int, error) { - ctx = setContextOp(ctx, ptq.ctx, ent.OpQueryCount) - if err := ptq.prepareQuery(ctx); err != nil { +func (_q *PasswordTokenQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount) + if err := _q.prepareQuery(ctx); err != nil { return 0, err } - return withInterceptors[int](ctx, ptq, querierCount[*PasswordTokenQuery](), ptq.inters) + return withInterceptors[int](ctx, _q, querierCount[*PasswordTokenQuery](), _q.inters) } // CountX is like Count, but panics if an error occurs. -func (ptq *PasswordTokenQuery) CountX(ctx context.Context) int { - count, err := ptq.Count(ctx) +func (_q *PasswordTokenQuery) CountX(ctx context.Context) int { + count, err := _q.Count(ctx) if err != nil { panic(err) } @@ -241,9 +241,9 @@ func (ptq *PasswordTokenQuery) CountX(ctx context.Context) int { } // Exist returns true if the query has elements in the graph. -func (ptq *PasswordTokenQuery) Exist(ctx context.Context) (bool, error) { - ctx = setContextOp(ctx, ptq.ctx, ent.OpQueryExist) - switch _, err := ptq.FirstID(ctx); { +func (_q *PasswordTokenQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist) + switch _, err := _q.FirstID(ctx); { case IsNotFound(err): return false, nil case err != nil: @@ -254,8 +254,8 @@ func (ptq *PasswordTokenQuery) Exist(ctx context.Context) (bool, error) { } // ExistX is like Exist, but panics if an error occurs. -func (ptq *PasswordTokenQuery) ExistX(ctx context.Context) bool { - exist, err := ptq.Exist(ctx) +func (_q *PasswordTokenQuery) ExistX(ctx context.Context) bool { + exist, err := _q.Exist(ctx) if err != nil { panic(err) } @@ -264,32 +264,32 @@ func (ptq *PasswordTokenQuery) ExistX(ctx context.Context) bool { // Clone returns a duplicate of the PasswordTokenQuery builder, including all associated steps. It can be // used to prepare common query builders and use them differently after the clone is made. -func (ptq *PasswordTokenQuery) Clone() *PasswordTokenQuery { - if ptq == nil { +func (_q *PasswordTokenQuery) Clone() *PasswordTokenQuery { + if _q == nil { return nil } return &PasswordTokenQuery{ - config: ptq.config, - ctx: ptq.ctx.Clone(), - order: append([]passwordtoken.OrderOption{}, ptq.order...), - inters: append([]Interceptor{}, ptq.inters...), - predicates: append([]predicate.PasswordToken{}, ptq.predicates...), - withUser: ptq.withUser.Clone(), + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]passwordtoken.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.PasswordToken{}, _q.predicates...), + withUser: _q.withUser.Clone(), // clone intermediate query. - sql: ptq.sql.Clone(), - path: ptq.path, + sql: _q.sql.Clone(), + path: _q.path, } } // WithUser tells the query-builder to eager-load the nodes that are connected to // the "user" edge. The optional arguments are used to configure the query builder of the edge. -func (ptq *PasswordTokenQuery) WithUser(opts ...func(*UserQuery)) *PasswordTokenQuery { - query := (&UserClient{config: ptq.config}).Query() +func (_q *PasswordTokenQuery) WithUser(opts ...func(*UserQuery)) *PasswordTokenQuery { + query := (&UserClient{config: _q.config}).Query() for _, opt := range opts { opt(query) } - ptq.withUser = query - return ptq + _q.withUser = query + return _q } // GroupBy is used to group vertices by one or more fields/columns. @@ -306,10 +306,10 @@ func (ptq *PasswordTokenQuery) WithUser(opts ...func(*UserQuery)) *PasswordToken // GroupBy(passwordtoken.FieldToken). // Aggregate(ent.Count()). // Scan(ctx, &v) -func (ptq *PasswordTokenQuery) GroupBy(field string, fields ...string) *PasswordTokenGroupBy { - ptq.ctx.Fields = append([]string{field}, fields...) - grbuild := &PasswordTokenGroupBy{build: ptq} - grbuild.flds = &ptq.ctx.Fields +func (_q *PasswordTokenQuery) GroupBy(field string, fields ...string) *PasswordTokenGroupBy { + _q.ctx.Fields = append([]string{field}, fields...) + grbuild := &PasswordTokenGroupBy{build: _q} + grbuild.flds = &_q.ctx.Fields grbuild.label = passwordtoken.Label grbuild.scan = grbuild.Scan return grbuild @@ -327,58 +327,58 @@ func (ptq *PasswordTokenQuery) GroupBy(field string, fields ...string) *Password // client.PasswordToken.Query(). // Select(passwordtoken.FieldToken). // Scan(ctx, &v) -func (ptq *PasswordTokenQuery) Select(fields ...string) *PasswordTokenSelect { - ptq.ctx.Fields = append(ptq.ctx.Fields, fields...) - sbuild := &PasswordTokenSelect{PasswordTokenQuery: ptq} +func (_q *PasswordTokenQuery) Select(fields ...string) *PasswordTokenSelect { + _q.ctx.Fields = append(_q.ctx.Fields, fields...) + sbuild := &PasswordTokenSelect{PasswordTokenQuery: _q} sbuild.label = passwordtoken.Label - sbuild.flds, sbuild.scan = &ptq.ctx.Fields, sbuild.Scan + sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan return sbuild } // Aggregate returns a PasswordTokenSelect configured with the given aggregations. -func (ptq *PasswordTokenQuery) Aggregate(fns ...AggregateFunc) *PasswordTokenSelect { - return ptq.Select().Aggregate(fns...) +func (_q *PasswordTokenQuery) Aggregate(fns ...AggregateFunc) *PasswordTokenSelect { + return _q.Select().Aggregate(fns...) } -func (ptq *PasswordTokenQuery) prepareQuery(ctx context.Context) error { - for _, inter := range ptq.inters { +func (_q *PasswordTokenQuery) prepareQuery(ctx context.Context) error { + for _, inter := range _q.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, ptq); err != nil { + if err := trv.Traverse(ctx, _q); err != nil { return err } } } - for _, f := range ptq.ctx.Fields { + for _, f := range _q.ctx.Fields { if !passwordtoken.ValidColumn(f) { return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} } } - if ptq.path != nil { - prev, err := ptq.path(ctx) + if _q.path != nil { + prev, err := _q.path(ctx) if err != nil { return err } - ptq.sql = prev + _q.sql = prev } return nil } -func (ptq *PasswordTokenQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*PasswordToken, error) { +func (_q *PasswordTokenQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*PasswordToken, error) { var ( nodes = []*PasswordToken{} - _spec = ptq.querySpec() + _spec = _q.querySpec() loadedTypes = [1]bool{ - ptq.withUser != nil, + _q.withUser != nil, } ) _spec.ScanValues = func(columns []string) ([]any, error) { return (*PasswordToken).scanValues(nil, columns) } _spec.Assign = func(columns []string, values []any) error { - node := &PasswordToken{config: ptq.config} + node := &PasswordToken{config: _q.config} nodes = append(nodes, node) node.Edges.loadedTypes = loadedTypes return node.assignValues(columns, values) @@ -386,14 +386,14 @@ func (ptq *PasswordTokenQuery) sqlAll(ctx context.Context, hooks ...queryHook) ( for i := range hooks { hooks[i](ctx, _spec) } - if err := sqlgraph.QueryNodes(ctx, ptq.driver, _spec); err != nil { + if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil { return nil, err } if len(nodes) == 0 { return nodes, nil } - if query := ptq.withUser; query != nil { - if err := ptq.loadUser(ctx, query, nodes, nil, + if query := _q.withUser; query != nil { + if err := _q.loadUser(ctx, query, nodes, nil, func(n *PasswordToken, e *User) { n.Edges.User = e }); err != nil { return nil, err } @@ -401,7 +401,7 @@ func (ptq *PasswordTokenQuery) sqlAll(ctx context.Context, hooks ...queryHook) ( return nodes, nil } -func (ptq *PasswordTokenQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*PasswordToken, init func(*PasswordToken), assign func(*PasswordToken, *User)) error { +func (_q *PasswordTokenQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*PasswordToken, init func(*PasswordToken), assign func(*PasswordToken, *User)) error { ids := make([]int, 0, len(nodes)) nodeids := make(map[int][]*PasswordToken) for i := range nodes { @@ -431,24 +431,24 @@ func (ptq *PasswordTokenQuery) loadUser(ctx context.Context, query *UserQuery, n return nil } -func (ptq *PasswordTokenQuery) sqlCount(ctx context.Context) (int, error) { - _spec := ptq.querySpec() - _spec.Node.Columns = ptq.ctx.Fields - if len(ptq.ctx.Fields) > 0 { - _spec.Unique = ptq.ctx.Unique != nil && *ptq.ctx.Unique +func (_q *PasswordTokenQuery) sqlCount(ctx context.Context) (int, error) { + _spec := _q.querySpec() + _spec.Node.Columns = _q.ctx.Fields + if len(_q.ctx.Fields) > 0 { + _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique } - return sqlgraph.CountNodes(ctx, ptq.driver, _spec) + return sqlgraph.CountNodes(ctx, _q.driver, _spec) } -func (ptq *PasswordTokenQuery) querySpec() *sqlgraph.QuerySpec { +func (_q *PasswordTokenQuery) querySpec() *sqlgraph.QuerySpec { _spec := sqlgraph.NewQuerySpec(passwordtoken.Table, passwordtoken.Columns, sqlgraph.NewFieldSpec(passwordtoken.FieldID, field.TypeInt)) - _spec.From = ptq.sql - if unique := ptq.ctx.Unique; unique != nil { + _spec.From = _q.sql + if unique := _q.ctx.Unique; unique != nil { _spec.Unique = *unique - } else if ptq.path != nil { + } else if _q.path != nil { _spec.Unique = true } - if fields := ptq.ctx.Fields; len(fields) > 0 { + if fields := _q.ctx.Fields; len(fields) > 0 { _spec.Node.Columns = make([]string, 0, len(fields)) _spec.Node.Columns = append(_spec.Node.Columns, passwordtoken.FieldID) for i := range fields { @@ -456,24 +456,24 @@ func (ptq *PasswordTokenQuery) querySpec() *sqlgraph.QuerySpec { _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) } } - if ptq.withUser != nil { + if _q.withUser != nil { _spec.Node.AddColumnOnce(passwordtoken.FieldUserID) } } - if ps := ptq.predicates; len(ps) > 0 { + if ps := _q.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - if limit := ptq.ctx.Limit; limit != nil { + if limit := _q.ctx.Limit; limit != nil { _spec.Limit = *limit } - if offset := ptq.ctx.Offset; offset != nil { + if offset := _q.ctx.Offset; offset != nil { _spec.Offset = *offset } - if ps := ptq.order; len(ps) > 0 { + if ps := _q.order; len(ps) > 0 { _spec.Order = func(selector *sql.Selector) { for i := range ps { ps[i](selector) @@ -483,33 +483,33 @@ func (ptq *PasswordTokenQuery) querySpec() *sqlgraph.QuerySpec { return _spec } -func (ptq *PasswordTokenQuery) sqlQuery(ctx context.Context) *sql.Selector { - builder := sql.Dialect(ptq.driver.Dialect()) +func (_q *PasswordTokenQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(_q.driver.Dialect()) t1 := builder.Table(passwordtoken.Table) - columns := ptq.ctx.Fields + columns := _q.ctx.Fields if len(columns) == 0 { columns = passwordtoken.Columns } selector := builder.Select(t1.Columns(columns...)...).From(t1) - if ptq.sql != nil { - selector = ptq.sql + if _q.sql != nil { + selector = _q.sql selector.Select(selector.Columns(columns...)...) } - if ptq.ctx.Unique != nil && *ptq.ctx.Unique { + if _q.ctx.Unique != nil && *_q.ctx.Unique { selector.Distinct() } - for _, p := range ptq.predicates { + for _, p := range _q.predicates { p(selector) } - for _, p := range ptq.order { + for _, p := range _q.order { p(selector) } - if offset := ptq.ctx.Offset; offset != nil { + if offset := _q.ctx.Offset; offset != nil { // limit is mandatory for offset clause. We start // with default value, and override it below if needed. selector.Offset(*offset).Limit(math.MaxInt32) } - if limit := ptq.ctx.Limit; limit != nil { + if limit := _q.ctx.Limit; limit != nil { selector.Limit(*limit) } return selector @@ -522,41 +522,41 @@ type PasswordTokenGroupBy struct { } // Aggregate adds the given aggregation functions to the group-by query. -func (ptgb *PasswordTokenGroupBy) Aggregate(fns ...AggregateFunc) *PasswordTokenGroupBy { - ptgb.fns = append(ptgb.fns, fns...) - return ptgb +func (_g *PasswordTokenGroupBy) Aggregate(fns ...AggregateFunc) *PasswordTokenGroupBy { + _g.fns = append(_g.fns, fns...) + return _g } // Scan applies the selector query and scans the result into the given value. -func (ptgb *PasswordTokenGroupBy) Scan(ctx context.Context, v any) error { - ctx = setContextOp(ctx, ptgb.build.ctx, ent.OpQueryGroupBy) - if err := ptgb.build.prepareQuery(ctx); err != nil { +func (_g *PasswordTokenGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy) + if err := _g.build.prepareQuery(ctx); err != nil { return err } - return scanWithInterceptors[*PasswordTokenQuery, *PasswordTokenGroupBy](ctx, ptgb.build, ptgb, ptgb.build.inters, v) + return scanWithInterceptors[*PasswordTokenQuery, *PasswordTokenGroupBy](ctx, _g.build, _g, _g.build.inters, v) } -func (ptgb *PasswordTokenGroupBy) sqlScan(ctx context.Context, root *PasswordTokenQuery, v any) error { +func (_g *PasswordTokenGroupBy) sqlScan(ctx context.Context, root *PasswordTokenQuery, v any) error { selector := root.sqlQuery(ctx).Select() - aggregation := make([]string, 0, len(ptgb.fns)) - for _, fn := range ptgb.fns { + aggregation := make([]string, 0, len(_g.fns)) + for _, fn := range _g.fns { aggregation = append(aggregation, fn(selector)) } if len(selector.SelectedColumns()) == 0 { - columns := make([]string, 0, len(*ptgb.flds)+len(ptgb.fns)) - for _, f := range *ptgb.flds { + columns := make([]string, 0, len(*_g.flds)+len(_g.fns)) + for _, f := range *_g.flds { columns = append(columns, selector.C(f)) } columns = append(columns, aggregation...) selector.Select(columns...) } - selector.GroupBy(selector.Columns(*ptgb.flds...)...) + selector.GroupBy(selector.Columns(*_g.flds...)...) if err := selector.Err(); err != nil { return err } rows := &sql.Rows{} query, args := selector.Query() - if err := ptgb.build.driver.Query(ctx, query, args, rows); err != nil { + if err := _g.build.driver.Query(ctx, query, args, rows); err != nil { return err } defer rows.Close() @@ -570,27 +570,27 @@ type PasswordTokenSelect struct { } // Aggregate adds the given aggregation functions to the selector query. -func (pts *PasswordTokenSelect) Aggregate(fns ...AggregateFunc) *PasswordTokenSelect { - pts.fns = append(pts.fns, fns...) - return pts +func (_s *PasswordTokenSelect) Aggregate(fns ...AggregateFunc) *PasswordTokenSelect { + _s.fns = append(_s.fns, fns...) + return _s } // Scan applies the selector query and scans the result into the given value. -func (pts *PasswordTokenSelect) Scan(ctx context.Context, v any) error { - ctx = setContextOp(ctx, pts.ctx, ent.OpQuerySelect) - if err := pts.prepareQuery(ctx); err != nil { +func (_s *PasswordTokenSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect) + if err := _s.prepareQuery(ctx); err != nil { return err } - return scanWithInterceptors[*PasswordTokenQuery, *PasswordTokenSelect](ctx, pts.PasswordTokenQuery, pts, pts.inters, v) + return scanWithInterceptors[*PasswordTokenQuery, *PasswordTokenSelect](ctx, _s.PasswordTokenQuery, _s, _s.inters, v) } -func (pts *PasswordTokenSelect) sqlScan(ctx context.Context, root *PasswordTokenQuery, v any) error { +func (_s *PasswordTokenSelect) sqlScan(ctx context.Context, root *PasswordTokenQuery, v any) error { selector := root.sqlQuery(ctx) - aggregation := make([]string, 0, len(pts.fns)) - for _, fn := range pts.fns { + aggregation := make([]string, 0, len(_s.fns)) + for _, fn := range _s.fns { aggregation = append(aggregation, fn(selector)) } - switch n := len(*pts.selector.flds); { + switch n := len(*_s.selector.flds); { case n == 0 && len(aggregation) > 0: selector.Select(aggregation...) case n != 0 && len(aggregation) > 0: @@ -598,7 +598,7 @@ func (pts *PasswordTokenSelect) sqlScan(ctx context.Context, root *PasswordToken } rows := &sql.Rows{} query, args := selector.Query() - if err := pts.driver.Query(ctx, query, args, rows); err != nil { + if err := _s.driver.Query(ctx, query, args, rows); err != nil { return err } defer rows.Close() diff --git a/ent/passwordtoken_update.go b/ent/passwordtoken_update.go index a0a0df2..de59b37 100644 --- a/ent/passwordtoken_update.go +++ b/ent/passwordtoken_update.go @@ -24,77 +24,77 @@ type PasswordTokenUpdate struct { } // Where appends a list predicates to the PasswordTokenUpdate builder. -func (ptu *PasswordTokenUpdate) Where(ps ...predicate.PasswordToken) *PasswordTokenUpdate { - ptu.mutation.Where(ps...) - return ptu +func (_u *PasswordTokenUpdate) Where(ps ...predicate.PasswordToken) *PasswordTokenUpdate { + _u.mutation.Where(ps...) + return _u } // SetToken sets the "token" field. -func (ptu *PasswordTokenUpdate) SetToken(s string) *PasswordTokenUpdate { - ptu.mutation.SetToken(s) - return ptu +func (_u *PasswordTokenUpdate) SetToken(v string) *PasswordTokenUpdate { + _u.mutation.SetToken(v) + return _u } // SetNillableToken sets the "token" field if the given value is not nil. -func (ptu *PasswordTokenUpdate) SetNillableToken(s *string) *PasswordTokenUpdate { - if s != nil { - ptu.SetToken(*s) +func (_u *PasswordTokenUpdate) SetNillableToken(v *string) *PasswordTokenUpdate { + if v != nil { + _u.SetToken(*v) } - return ptu + return _u } // SetUserID sets the "user_id" field. -func (ptu *PasswordTokenUpdate) SetUserID(i int) *PasswordTokenUpdate { - ptu.mutation.SetUserID(i) - return ptu +func (_u *PasswordTokenUpdate) SetUserID(v int) *PasswordTokenUpdate { + _u.mutation.SetUserID(v) + return _u } // SetNillableUserID sets the "user_id" field if the given value is not nil. -func (ptu *PasswordTokenUpdate) SetNillableUserID(i *int) *PasswordTokenUpdate { - if i != nil { - ptu.SetUserID(*i) +func (_u *PasswordTokenUpdate) SetNillableUserID(v *int) *PasswordTokenUpdate { + if v != nil { + _u.SetUserID(*v) } - return ptu + return _u } // SetCreatedAt sets the "created_at" field. -func (ptu *PasswordTokenUpdate) SetCreatedAt(t time.Time) *PasswordTokenUpdate { - ptu.mutation.SetCreatedAt(t) - return ptu +func (_u *PasswordTokenUpdate) SetCreatedAt(v time.Time) *PasswordTokenUpdate { + _u.mutation.SetCreatedAt(v) + return _u } // SetNillableCreatedAt sets the "created_at" field if the given value is not nil. -func (ptu *PasswordTokenUpdate) SetNillableCreatedAt(t *time.Time) *PasswordTokenUpdate { - if t != nil { - ptu.SetCreatedAt(*t) +func (_u *PasswordTokenUpdate) SetNillableCreatedAt(v *time.Time) *PasswordTokenUpdate { + if v != nil { + _u.SetCreatedAt(*v) } - return ptu + return _u } // SetUser sets the "user" edge to the User entity. -func (ptu *PasswordTokenUpdate) SetUser(u *User) *PasswordTokenUpdate { - return ptu.SetUserID(u.ID) +func (_u *PasswordTokenUpdate) SetUser(v *User) *PasswordTokenUpdate { + return _u.SetUserID(v.ID) } // Mutation returns the PasswordTokenMutation object of the builder. -func (ptu *PasswordTokenUpdate) Mutation() *PasswordTokenMutation { - return ptu.mutation +func (_u *PasswordTokenUpdate) Mutation() *PasswordTokenMutation { + return _u.mutation } // ClearUser clears the "user" edge to the User entity. -func (ptu *PasswordTokenUpdate) ClearUser() *PasswordTokenUpdate { - ptu.mutation.ClearUser() - return ptu +func (_u *PasswordTokenUpdate) ClearUser() *PasswordTokenUpdate { + _u.mutation.ClearUser() + return _u } // Save executes the query and returns the number of nodes affected by the update operation. -func (ptu *PasswordTokenUpdate) Save(ctx context.Context) (int, error) { - return withHooks(ctx, ptu.sqlSave, ptu.mutation, ptu.hooks) +func (_u *PasswordTokenUpdate) Save(ctx context.Context) (int, error) { + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) } // SaveX is like Save, but panics if an error occurs. -func (ptu *PasswordTokenUpdate) SaveX(ctx context.Context) int { - affected, err := ptu.Save(ctx) +func (_u *PasswordTokenUpdate) SaveX(ctx context.Context) int { + affected, err := _u.Save(ctx) if err != nil { panic(err) } @@ -102,50 +102,50 @@ func (ptu *PasswordTokenUpdate) SaveX(ctx context.Context) int { } // Exec executes the query. -func (ptu *PasswordTokenUpdate) Exec(ctx context.Context) error { - _, err := ptu.Save(ctx) +func (_u *PasswordTokenUpdate) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (ptu *PasswordTokenUpdate) ExecX(ctx context.Context) { - if err := ptu.Exec(ctx); err != nil { +func (_u *PasswordTokenUpdate) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { panic(err) } } // check runs all checks and user-defined validators on the builder. -func (ptu *PasswordTokenUpdate) check() error { - if v, ok := ptu.mutation.Token(); ok { +func (_u *PasswordTokenUpdate) check() error { + if v, ok := _u.mutation.Token(); ok { if err := passwordtoken.TokenValidator(v); err != nil { return &ValidationError{Name: "token", err: fmt.Errorf(`ent: validator failed for field "PasswordToken.token": %w`, err)} } } - if ptu.mutation.UserCleared() && len(ptu.mutation.UserIDs()) > 0 { + if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 { return errors.New(`ent: clearing a required unique edge "PasswordToken.user"`) } return nil } -func (ptu *PasswordTokenUpdate) sqlSave(ctx context.Context) (n int, err error) { - if err := ptu.check(); err != nil { - return n, err +func (_u *PasswordTokenUpdate) sqlSave(ctx context.Context) (_node int, err error) { + if err := _u.check(); err != nil { + return _node, err } _spec := sqlgraph.NewUpdateSpec(passwordtoken.Table, passwordtoken.Columns, sqlgraph.NewFieldSpec(passwordtoken.FieldID, field.TypeInt)) - if ps := ptu.mutation.predicates; len(ps) > 0 { + if ps := _u.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - if value, ok := ptu.mutation.Token(); ok { + if value, ok := _u.mutation.Token(); ok { _spec.SetField(passwordtoken.FieldToken, field.TypeString, value) } - if value, ok := ptu.mutation.CreatedAt(); ok { + if value, ok := _u.mutation.CreatedAt(); ok { _spec.SetField(passwordtoken.FieldCreatedAt, field.TypeTime, value) } - if ptu.mutation.UserCleared() { + if _u.mutation.UserCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.M2O, Inverse: false, @@ -158,7 +158,7 @@ func (ptu *PasswordTokenUpdate) sqlSave(ctx context.Context) (n int, err error) } _spec.Edges.Clear = append(_spec.Edges.Clear, edge) } - if nodes := ptu.mutation.UserIDs(); len(nodes) > 0 { + if nodes := _u.mutation.UserIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.M2O, Inverse: false, @@ -174,7 +174,7 @@ func (ptu *PasswordTokenUpdate) sqlSave(ctx context.Context) (n int, err error) } _spec.Edges.Add = append(_spec.Edges.Add, edge) } - if n, err = sqlgraph.UpdateNodes(ctx, ptu.driver, _spec); err != nil { + if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{passwordtoken.Label} } else if sqlgraph.IsConstraintError(err) { @@ -182,8 +182,8 @@ func (ptu *PasswordTokenUpdate) sqlSave(ctx context.Context) (n int, err error) } return 0, err } - ptu.mutation.done = true - return n, nil + _u.mutation.done = true + return _node, nil } // PasswordTokenUpdateOne is the builder for updating a single PasswordToken entity. @@ -195,84 +195,84 @@ type PasswordTokenUpdateOne struct { } // SetToken sets the "token" field. -func (ptuo *PasswordTokenUpdateOne) SetToken(s string) *PasswordTokenUpdateOne { - ptuo.mutation.SetToken(s) - return ptuo +func (_u *PasswordTokenUpdateOne) SetToken(v string) *PasswordTokenUpdateOne { + _u.mutation.SetToken(v) + return _u } // SetNillableToken sets the "token" field if the given value is not nil. -func (ptuo *PasswordTokenUpdateOne) SetNillableToken(s *string) *PasswordTokenUpdateOne { - if s != nil { - ptuo.SetToken(*s) +func (_u *PasswordTokenUpdateOne) SetNillableToken(v *string) *PasswordTokenUpdateOne { + if v != nil { + _u.SetToken(*v) } - return ptuo + return _u } // SetUserID sets the "user_id" field. -func (ptuo *PasswordTokenUpdateOne) SetUserID(i int) *PasswordTokenUpdateOne { - ptuo.mutation.SetUserID(i) - return ptuo +func (_u *PasswordTokenUpdateOne) SetUserID(v int) *PasswordTokenUpdateOne { + _u.mutation.SetUserID(v) + return _u } // SetNillableUserID sets the "user_id" field if the given value is not nil. -func (ptuo *PasswordTokenUpdateOne) SetNillableUserID(i *int) *PasswordTokenUpdateOne { - if i != nil { - ptuo.SetUserID(*i) +func (_u *PasswordTokenUpdateOne) SetNillableUserID(v *int) *PasswordTokenUpdateOne { + if v != nil { + _u.SetUserID(*v) } - return ptuo + return _u } // SetCreatedAt sets the "created_at" field. -func (ptuo *PasswordTokenUpdateOne) SetCreatedAt(t time.Time) *PasswordTokenUpdateOne { - ptuo.mutation.SetCreatedAt(t) - return ptuo +func (_u *PasswordTokenUpdateOne) SetCreatedAt(v time.Time) *PasswordTokenUpdateOne { + _u.mutation.SetCreatedAt(v) + return _u } // SetNillableCreatedAt sets the "created_at" field if the given value is not nil. -func (ptuo *PasswordTokenUpdateOne) SetNillableCreatedAt(t *time.Time) *PasswordTokenUpdateOne { - if t != nil { - ptuo.SetCreatedAt(*t) +func (_u *PasswordTokenUpdateOne) SetNillableCreatedAt(v *time.Time) *PasswordTokenUpdateOne { + if v != nil { + _u.SetCreatedAt(*v) } - return ptuo + return _u } // SetUser sets the "user" edge to the User entity. -func (ptuo *PasswordTokenUpdateOne) SetUser(u *User) *PasswordTokenUpdateOne { - return ptuo.SetUserID(u.ID) +func (_u *PasswordTokenUpdateOne) SetUser(v *User) *PasswordTokenUpdateOne { + return _u.SetUserID(v.ID) } // Mutation returns the PasswordTokenMutation object of the builder. -func (ptuo *PasswordTokenUpdateOne) Mutation() *PasswordTokenMutation { - return ptuo.mutation +func (_u *PasswordTokenUpdateOne) Mutation() *PasswordTokenMutation { + return _u.mutation } // ClearUser clears the "user" edge to the User entity. -func (ptuo *PasswordTokenUpdateOne) ClearUser() *PasswordTokenUpdateOne { - ptuo.mutation.ClearUser() - return ptuo +func (_u *PasswordTokenUpdateOne) ClearUser() *PasswordTokenUpdateOne { + _u.mutation.ClearUser() + return _u } // Where appends a list predicates to the PasswordTokenUpdate builder. -func (ptuo *PasswordTokenUpdateOne) Where(ps ...predicate.PasswordToken) *PasswordTokenUpdateOne { - ptuo.mutation.Where(ps...) - return ptuo +func (_u *PasswordTokenUpdateOne) Where(ps ...predicate.PasswordToken) *PasswordTokenUpdateOne { + _u.mutation.Where(ps...) + return _u } // Select allows selecting one or more fields (columns) of the returned entity. // The default is selecting all fields defined in the entity schema. -func (ptuo *PasswordTokenUpdateOne) Select(field string, fields ...string) *PasswordTokenUpdateOne { - ptuo.fields = append([]string{field}, fields...) - return ptuo +func (_u *PasswordTokenUpdateOne) Select(field string, fields ...string) *PasswordTokenUpdateOne { + _u.fields = append([]string{field}, fields...) + return _u } // Save executes the query and returns the updated PasswordToken entity. -func (ptuo *PasswordTokenUpdateOne) Save(ctx context.Context) (*PasswordToken, error) { - return withHooks(ctx, ptuo.sqlSave, ptuo.mutation, ptuo.hooks) +func (_u *PasswordTokenUpdateOne) Save(ctx context.Context) (*PasswordToken, error) { + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) } // SaveX is like Save, but panics if an error occurs. -func (ptuo *PasswordTokenUpdateOne) SaveX(ctx context.Context) *PasswordToken { - node, err := ptuo.Save(ctx) +func (_u *PasswordTokenUpdateOne) SaveX(ctx context.Context) *PasswordToken { + node, err := _u.Save(ctx) if err != nil { panic(err) } @@ -280,42 +280,42 @@ func (ptuo *PasswordTokenUpdateOne) SaveX(ctx context.Context) *PasswordToken { } // Exec executes the query on the entity. -func (ptuo *PasswordTokenUpdateOne) Exec(ctx context.Context) error { - _, err := ptuo.Save(ctx) +func (_u *PasswordTokenUpdateOne) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (ptuo *PasswordTokenUpdateOne) ExecX(ctx context.Context) { - if err := ptuo.Exec(ctx); err != nil { +func (_u *PasswordTokenUpdateOne) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { panic(err) } } // check runs all checks and user-defined validators on the builder. -func (ptuo *PasswordTokenUpdateOne) check() error { - if v, ok := ptuo.mutation.Token(); ok { +func (_u *PasswordTokenUpdateOne) check() error { + if v, ok := _u.mutation.Token(); ok { if err := passwordtoken.TokenValidator(v); err != nil { return &ValidationError{Name: "token", err: fmt.Errorf(`ent: validator failed for field "PasswordToken.token": %w`, err)} } } - if ptuo.mutation.UserCleared() && len(ptuo.mutation.UserIDs()) > 0 { + if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 { return errors.New(`ent: clearing a required unique edge "PasswordToken.user"`) } return nil } -func (ptuo *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *PasswordToken, err error) { - if err := ptuo.check(); err != nil { +func (_u *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *PasswordToken, err error) { + if err := _u.check(); err != nil { return _node, err } _spec := sqlgraph.NewUpdateSpec(passwordtoken.Table, passwordtoken.Columns, sqlgraph.NewFieldSpec(passwordtoken.FieldID, field.TypeInt)) - id, ok := ptuo.mutation.ID() + id, ok := _u.mutation.ID() if !ok { return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "PasswordToken.id" for update`)} } _spec.Node.ID.Value = id - if fields := ptuo.fields; len(fields) > 0 { + if fields := _u.fields; len(fields) > 0 { _spec.Node.Columns = make([]string, 0, len(fields)) _spec.Node.Columns = append(_spec.Node.Columns, passwordtoken.FieldID) for _, f := range fields { @@ -327,20 +327,20 @@ func (ptuo *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *Passwor } } } - if ps := ptuo.mutation.predicates; len(ps) > 0 { + if ps := _u.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - if value, ok := ptuo.mutation.Token(); ok { + if value, ok := _u.mutation.Token(); ok { _spec.SetField(passwordtoken.FieldToken, field.TypeString, value) } - if value, ok := ptuo.mutation.CreatedAt(); ok { + if value, ok := _u.mutation.CreatedAt(); ok { _spec.SetField(passwordtoken.FieldCreatedAt, field.TypeTime, value) } - if ptuo.mutation.UserCleared() { + if _u.mutation.UserCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.M2O, Inverse: false, @@ -353,7 +353,7 @@ func (ptuo *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *Passwor } _spec.Edges.Clear = append(_spec.Edges.Clear, edge) } - if nodes := ptuo.mutation.UserIDs(); len(nodes) > 0 { + if nodes := _u.mutation.UserIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.M2O, Inverse: false, @@ -369,10 +369,10 @@ func (ptuo *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *Passwor } _spec.Edges.Add = append(_spec.Edges.Add, edge) } - _node = &PasswordToken{config: ptuo.config} + _node = &PasswordToken{config: _u.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues - if err = sqlgraph.UpdateNode(ctx, ptuo.driver, _spec); err != nil { + if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{passwordtoken.Label} } else if sqlgraph.IsConstraintError(err) { @@ -380,6 +380,6 @@ func (ptuo *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *Passwor } return nil, err } - ptuo.mutation.done = true + _u.mutation.done = true return _node, nil } diff --git a/ent/runtime/runtime.go b/ent/runtime/runtime.go index 5b0401e..e76534e 100644 --- a/ent/runtime/runtime.go +++ b/ent/runtime/runtime.go @@ -71,6 +71,6 @@ func init() { } const ( - Version = "v0.14.4" // Version of ent codegen. - Sum = "h1:/DhDraSLXIkBhyiVoJeSshr4ZYi7femzhj6/TckzZuI=" // Sum of ent codegen. + Version = "v0.14.5" // Version of ent codegen. + Sum = "h1:Rj2WOYJtCkWyFo6a+5wB3EfBRP0rnx1fMk6gGA0UUe4=" // Sum of ent codegen. ) diff --git a/ent/user.go b/ent/user.go index 70de1e5..11a2015 100644 --- a/ent/user.go +++ b/ent/user.go @@ -75,7 +75,7 @@ func (*User) scanValues(columns []string) ([]any, error) { // assignValues assigns the values that were returned from sql.Rows (after scanning) // to the User fields. -func (u *User) assignValues(columns []string, values []any) error { +func (_m *User) assignValues(columns []string, values []any) error { if m, n := len(values), len(columns); m < n { return fmt.Errorf("mismatch number of scan values: %d != %d", m, n) } @@ -86,45 +86,45 @@ func (u *User) assignValues(columns []string, values []any) error { if !ok { return fmt.Errorf("unexpected type %T for field id", value) } - u.ID = int(value.Int64) + _m.ID = int(value.Int64) case user.FieldName: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field name", values[i]) } else if value.Valid { - u.Name = value.String + _m.Name = value.String } case user.FieldEmail: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field email", values[i]) } else if value.Valid { - u.Email = value.String + _m.Email = value.String } case user.FieldPassword: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field password", values[i]) } else if value.Valid { - u.Password = value.String + _m.Password = value.String } case user.FieldVerified: if value, ok := values[i].(*sql.NullBool); !ok { return fmt.Errorf("unexpected type %T for field verified", values[i]) } else if value.Valid { - u.Verified = value.Bool + _m.Verified = value.Bool } case user.FieldAdmin: if value, ok := values[i].(*sql.NullBool); !ok { return fmt.Errorf("unexpected type %T for field admin", values[i]) } else if value.Valid { - u.Admin = value.Bool + _m.Admin = value.Bool } case user.FieldCreatedAt: if value, ok := values[i].(*sql.NullTime); !ok { return fmt.Errorf("unexpected type %T for field created_at", values[i]) } else if value.Valid { - u.CreatedAt = value.Time + _m.CreatedAt = value.Time } default: - u.selectValues.Set(columns[i], values[i]) + _m.selectValues.Set(columns[i], values[i]) } } return nil @@ -132,54 +132,54 @@ func (u *User) assignValues(columns []string, values []any) error { // Value returns the ent.Value that was dynamically selected and assigned to the User. // This includes values selected through modifiers, order, etc. -func (u *User) Value(name string) (ent.Value, error) { - return u.selectValues.Get(name) +func (_m *User) Value(name string) (ent.Value, error) { + return _m.selectValues.Get(name) } // QueryOwner queries the "owner" edge of the User entity. -func (u *User) QueryOwner() *PasswordTokenQuery { - return NewUserClient(u.config).QueryOwner(u) +func (_m *User) QueryOwner() *PasswordTokenQuery { + return NewUserClient(_m.config).QueryOwner(_m) } // Update returns a builder for updating this User. // Note that you need to call User.Unwrap() before calling this method if this User // was returned from a transaction, and the transaction was committed or rolled back. -func (u *User) Update() *UserUpdateOne { - return NewUserClient(u.config).UpdateOne(u) +func (_m *User) Update() *UserUpdateOne { + return NewUserClient(_m.config).UpdateOne(_m) } // Unwrap unwraps the User entity that was returned from a transaction after it was closed, // so that all future queries will be executed through the driver which created the transaction. -func (u *User) Unwrap() *User { - _tx, ok := u.config.driver.(*txDriver) +func (_m *User) Unwrap() *User { + _tx, ok := _m.config.driver.(*txDriver) if !ok { panic("ent: User is not a transactional entity") } - u.config.driver = _tx.drv - return u + _m.config.driver = _tx.drv + return _m } // String implements the fmt.Stringer. -func (u *User) String() string { +func (_m *User) String() string { var builder strings.Builder builder.WriteString("User(") - builder.WriteString(fmt.Sprintf("id=%v, ", u.ID)) + builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID)) builder.WriteString("name=") - builder.WriteString(u.Name) + builder.WriteString(_m.Name) builder.WriteString(", ") builder.WriteString("email=") - builder.WriteString(u.Email) + builder.WriteString(_m.Email) builder.WriteString(", ") builder.WriteString("password=") builder.WriteString(", ") builder.WriteString("verified=") - builder.WriteString(fmt.Sprintf("%v", u.Verified)) + builder.WriteString(fmt.Sprintf("%v", _m.Verified)) builder.WriteString(", ") builder.WriteString("admin=") - builder.WriteString(fmt.Sprintf("%v", u.Admin)) + builder.WriteString(fmt.Sprintf("%v", _m.Admin)) builder.WriteString(", ") builder.WriteString("created_at=") - builder.WriteString(u.CreatedAt.Format(time.ANSIC)) + builder.WriteString(_m.CreatedAt.Format(time.ANSIC)) builder.WriteByte(')') return builder.String() } diff --git a/ent/user_create.go b/ent/user_create.go index dfca9e6..ae14177 100644 --- a/ent/user_create.go +++ b/ent/user_create.go @@ -22,96 +22,96 @@ type UserCreate struct { } // SetName sets the "name" field. -func (uc *UserCreate) SetName(s string) *UserCreate { - uc.mutation.SetName(s) - return uc +func (_c *UserCreate) SetName(v string) *UserCreate { + _c.mutation.SetName(v) + return _c } // SetEmail sets the "email" field. -func (uc *UserCreate) SetEmail(s string) *UserCreate { - uc.mutation.SetEmail(s) - return uc +func (_c *UserCreate) SetEmail(v string) *UserCreate { + _c.mutation.SetEmail(v) + return _c } // SetPassword sets the "password" field. -func (uc *UserCreate) SetPassword(s string) *UserCreate { - uc.mutation.SetPassword(s) - return uc +func (_c *UserCreate) SetPassword(v string) *UserCreate { + _c.mutation.SetPassword(v) + return _c } // SetVerified sets the "verified" field. -func (uc *UserCreate) SetVerified(b bool) *UserCreate { - uc.mutation.SetVerified(b) - return uc +func (_c *UserCreate) SetVerified(v bool) *UserCreate { + _c.mutation.SetVerified(v) + return _c } // SetNillableVerified sets the "verified" field if the given value is not nil. -func (uc *UserCreate) SetNillableVerified(b *bool) *UserCreate { - if b != nil { - uc.SetVerified(*b) +func (_c *UserCreate) SetNillableVerified(v *bool) *UserCreate { + if v != nil { + _c.SetVerified(*v) } - return uc + return _c } // SetAdmin sets the "admin" field. -func (uc *UserCreate) SetAdmin(b bool) *UserCreate { - uc.mutation.SetAdmin(b) - return uc +func (_c *UserCreate) SetAdmin(v bool) *UserCreate { + _c.mutation.SetAdmin(v) + return _c } // SetNillableAdmin sets the "admin" field if the given value is not nil. -func (uc *UserCreate) SetNillableAdmin(b *bool) *UserCreate { - if b != nil { - uc.SetAdmin(*b) +func (_c *UserCreate) SetNillableAdmin(v *bool) *UserCreate { + if v != nil { + _c.SetAdmin(*v) } - return uc + return _c } // SetCreatedAt sets the "created_at" field. -func (uc *UserCreate) SetCreatedAt(t time.Time) *UserCreate { - uc.mutation.SetCreatedAt(t) - return uc +func (_c *UserCreate) SetCreatedAt(v time.Time) *UserCreate { + _c.mutation.SetCreatedAt(v) + return _c } // SetNillableCreatedAt sets the "created_at" field if the given value is not nil. -func (uc *UserCreate) SetNillableCreatedAt(t *time.Time) *UserCreate { - if t != nil { - uc.SetCreatedAt(*t) +func (_c *UserCreate) SetNillableCreatedAt(v *time.Time) *UserCreate { + if v != nil { + _c.SetCreatedAt(*v) } - return uc + return _c } // AddOwnerIDs adds the "owner" edge to the PasswordToken entity by IDs. -func (uc *UserCreate) AddOwnerIDs(ids ...int) *UserCreate { - uc.mutation.AddOwnerIDs(ids...) - return uc +func (_c *UserCreate) AddOwnerIDs(ids ...int) *UserCreate { + _c.mutation.AddOwnerIDs(ids...) + return _c } // AddOwner adds the "owner" edges to the PasswordToken entity. -func (uc *UserCreate) AddOwner(p ...*PasswordToken) *UserCreate { - ids := make([]int, len(p)) - for i := range p { - ids[i] = p[i].ID +func (_c *UserCreate) AddOwner(v ...*PasswordToken) *UserCreate { + ids := make([]int, len(v)) + for i := range v { + ids[i] = v[i].ID } - return uc.AddOwnerIDs(ids...) + return _c.AddOwnerIDs(ids...) } // Mutation returns the UserMutation object of the builder. -func (uc *UserCreate) Mutation() *UserMutation { - return uc.mutation +func (_c *UserCreate) Mutation() *UserMutation { + return _c.mutation } // Save creates the User in the database. -func (uc *UserCreate) Save(ctx context.Context) (*User, error) { - if err := uc.defaults(); err != nil { +func (_c *UserCreate) Save(ctx context.Context) (*User, error) { + if err := _c.defaults(); err != nil { return nil, err } - return withHooks(ctx, uc.sqlSave, uc.mutation, uc.hooks) + return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks) } // SaveX calls Save and panics if Save returns an error. -func (uc *UserCreate) SaveX(ctx context.Context) *User { - v, err := uc.Save(ctx) +func (_c *UserCreate) SaveX(ctx context.Context) *User { + v, err := _c.Save(ctx) if err != nil { panic(err) } @@ -119,82 +119,82 @@ func (uc *UserCreate) SaveX(ctx context.Context) *User { } // Exec executes the query. -func (uc *UserCreate) Exec(ctx context.Context) error { - _, err := uc.Save(ctx) +func (_c *UserCreate) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (uc *UserCreate) ExecX(ctx context.Context) { - if err := uc.Exec(ctx); err != nil { +func (_c *UserCreate) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { panic(err) } } // defaults sets the default values of the builder before save. -func (uc *UserCreate) defaults() error { - if _, ok := uc.mutation.Verified(); !ok { +func (_c *UserCreate) defaults() error { + if _, ok := _c.mutation.Verified(); !ok { v := user.DefaultVerified - uc.mutation.SetVerified(v) + _c.mutation.SetVerified(v) } - if _, ok := uc.mutation.Admin(); !ok { + if _, ok := _c.mutation.Admin(); !ok { v := user.DefaultAdmin - uc.mutation.SetAdmin(v) + _c.mutation.SetAdmin(v) } - if _, ok := uc.mutation.CreatedAt(); !ok { + if _, ok := _c.mutation.CreatedAt(); !ok { if user.DefaultCreatedAt == nil { return fmt.Errorf("ent: uninitialized user.DefaultCreatedAt (forgotten import ent/runtime?)") } v := user.DefaultCreatedAt() - uc.mutation.SetCreatedAt(v) + _c.mutation.SetCreatedAt(v) } return nil } // check runs all checks and user-defined validators on the builder. -func (uc *UserCreate) check() error { - if _, ok := uc.mutation.Name(); !ok { +func (_c *UserCreate) check() error { + if _, ok := _c.mutation.Name(); !ok { return &ValidationError{Name: "name", err: errors.New(`ent: missing required field "User.name"`)} } - if v, ok := uc.mutation.Name(); ok { + if v, ok := _c.mutation.Name(); ok { if err := user.NameValidator(v); err != nil { return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "User.name": %w`, err)} } } - if _, ok := uc.mutation.Email(); !ok { + if _, ok := _c.mutation.Email(); !ok { return &ValidationError{Name: "email", err: errors.New(`ent: missing required field "User.email"`)} } - if v, ok := uc.mutation.Email(); ok { + if v, ok := _c.mutation.Email(); ok { if err := user.EmailValidator(v); err != nil { return &ValidationError{Name: "email", err: fmt.Errorf(`ent: validator failed for field "User.email": %w`, err)} } } - if _, ok := uc.mutation.Password(); !ok { + if _, ok := _c.mutation.Password(); !ok { return &ValidationError{Name: "password", err: errors.New(`ent: missing required field "User.password"`)} } - if v, ok := uc.mutation.Password(); ok { + if v, ok := _c.mutation.Password(); ok { if err := user.PasswordValidator(v); err != nil { return &ValidationError{Name: "password", err: fmt.Errorf(`ent: validator failed for field "User.password": %w`, err)} } } - if _, ok := uc.mutation.Verified(); !ok { + if _, ok := _c.mutation.Verified(); !ok { return &ValidationError{Name: "verified", err: errors.New(`ent: missing required field "User.verified"`)} } - if _, ok := uc.mutation.Admin(); !ok { + if _, ok := _c.mutation.Admin(); !ok { return &ValidationError{Name: "admin", err: errors.New(`ent: missing required field "User.admin"`)} } - if _, ok := uc.mutation.CreatedAt(); !ok { + if _, ok := _c.mutation.CreatedAt(); !ok { return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "User.created_at"`)} } return nil } -func (uc *UserCreate) sqlSave(ctx context.Context) (*User, error) { - if err := uc.check(); err != nil { +func (_c *UserCreate) sqlSave(ctx context.Context) (*User, error) { + if err := _c.check(); err != nil { return nil, err } - _node, _spec := uc.createSpec() - if err := sqlgraph.CreateNode(ctx, uc.driver, _spec); err != nil { + _node, _spec := _c.createSpec() + if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil { if sqlgraph.IsConstraintError(err) { err = &ConstraintError{msg: err.Error(), wrap: err} } @@ -202,41 +202,41 @@ func (uc *UserCreate) sqlSave(ctx context.Context) (*User, error) { } id := _spec.ID.Value.(int64) _node.ID = int(id) - uc.mutation.id = &_node.ID - uc.mutation.done = true + _c.mutation.id = &_node.ID + _c.mutation.done = true return _node, nil } -func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { +func (_c *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { var ( - _node = &User{config: uc.config} + _node = &User{config: _c.config} _spec = sqlgraph.NewCreateSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) ) - if value, ok := uc.mutation.Name(); ok { + if value, ok := _c.mutation.Name(); ok { _spec.SetField(user.FieldName, field.TypeString, value) _node.Name = value } - if value, ok := uc.mutation.Email(); ok { + if value, ok := _c.mutation.Email(); ok { _spec.SetField(user.FieldEmail, field.TypeString, value) _node.Email = value } - if value, ok := uc.mutation.Password(); ok { + if value, ok := _c.mutation.Password(); ok { _spec.SetField(user.FieldPassword, field.TypeString, value) _node.Password = value } - if value, ok := uc.mutation.Verified(); ok { + if value, ok := _c.mutation.Verified(); ok { _spec.SetField(user.FieldVerified, field.TypeBool, value) _node.Verified = value } - if value, ok := uc.mutation.Admin(); ok { + if value, ok := _c.mutation.Admin(); ok { _spec.SetField(user.FieldAdmin, field.TypeBool, value) _node.Admin = value } - if value, ok := uc.mutation.CreatedAt(); ok { + if value, ok := _c.mutation.CreatedAt(); ok { _spec.SetField(user.FieldCreatedAt, field.TypeTime, value) _node.CreatedAt = value } - if nodes := uc.mutation.OwnerIDs(); len(nodes) > 0 { + if nodes := _c.mutation.OwnerIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, Inverse: true, @@ -263,16 +263,16 @@ type UserCreateBulk struct { } // Save creates the User entities in the database. -func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { - if ucb.err != nil { - return nil, ucb.err +func (_c *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if _c.err != nil { + return nil, _c.err } - specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) - nodes := make([]*User, len(ucb.builders)) - mutators := make([]Mutator, len(ucb.builders)) - for i := range ucb.builders { + specs := make([]*sqlgraph.CreateSpec, len(_c.builders)) + nodes := make([]*User, len(_c.builders)) + mutators := make([]Mutator, len(_c.builders)) + for i := range _c.builders { func(i int, root context.Context) { - builder := ucb.builders[i] + builder := _c.builders[i] builder.defaults() var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { mutation, ok := m.(*UserMutation) @@ -286,11 +286,11 @@ func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { var err error nodes[i], specs[i] = builder.createSpec() if i < len(mutators)-1 { - _, err = mutators[i+1].Mutate(root, ucb.builders[i+1].mutation) + _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation) } else { spec := &sqlgraph.BatchCreateSpec{Nodes: specs} // Invoke the actual operation on the latest mutation in the chain. - if err = sqlgraph.BatchCreate(ctx, ucb.driver, spec); err != nil { + if err = sqlgraph.BatchCreate(ctx, _c.driver, spec); err != nil { if sqlgraph.IsConstraintError(err) { err = &ConstraintError{msg: err.Error(), wrap: err} } @@ -314,7 +314,7 @@ func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { }(i, ctx) } if len(mutators) > 0 { - if _, err := mutators[0].Mutate(ctx, ucb.builders[0].mutation); err != nil { + if _, err := mutators[0].Mutate(ctx, _c.builders[0].mutation); err != nil { return nil, err } } @@ -322,8 +322,8 @@ func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { } // SaveX is like Save, but panics if an error occurs. -func (ucb *UserCreateBulk) SaveX(ctx context.Context) []*User { - v, err := ucb.Save(ctx) +func (_c *UserCreateBulk) SaveX(ctx context.Context) []*User { + v, err := _c.Save(ctx) if err != nil { panic(err) } @@ -331,14 +331,14 @@ func (ucb *UserCreateBulk) SaveX(ctx context.Context) []*User { } // Exec executes the query. -func (ucb *UserCreateBulk) Exec(ctx context.Context) error { - _, err := ucb.Save(ctx) +func (_c *UserCreateBulk) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (ucb *UserCreateBulk) ExecX(ctx context.Context) { - if err := ucb.Exec(ctx); err != nil { +func (_c *UserCreateBulk) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { panic(err) } } diff --git a/ent/user_delete.go b/ent/user_delete.go index ed884c8..4a51d5a 100644 --- a/ent/user_delete.go +++ b/ent/user_delete.go @@ -20,56 +20,56 @@ type UserDelete struct { } // Where appends a list predicates to the UserDelete builder. -func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { - ud.mutation.Where(ps...) - return ud +func (_d *UserDelete) Where(ps ...predicate.User) *UserDelete { + _d.mutation.Where(ps...) + return _d } // Exec executes the deletion query and returns how many vertices were deleted. -func (ud *UserDelete) Exec(ctx context.Context) (int, error) { - return withHooks(ctx, ud.sqlExec, ud.mutation, ud.hooks) +func (_d *UserDelete) Exec(ctx context.Context) (int, error) { + return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks) } // ExecX is like Exec, but panics if an error occurs. -func (ud *UserDelete) ExecX(ctx context.Context) int { - n, err := ud.Exec(ctx) +func (_d *UserDelete) ExecX(ctx context.Context) int { + n, err := _d.Exec(ctx) if err != nil { panic(err) } return n } -func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { +func (_d *UserDelete) sqlExec(ctx context.Context) (int, error) { _spec := sqlgraph.NewDeleteSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) - if ps := ud.mutation.predicates; len(ps) > 0 { + if ps := _d.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - affected, err := sqlgraph.DeleteNodes(ctx, ud.driver, _spec) + affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec) if err != nil && sqlgraph.IsConstraintError(err) { err = &ConstraintError{msg: err.Error(), wrap: err} } - ud.mutation.done = true + _d.mutation.done = true return affected, err } // UserDeleteOne is the builder for deleting a single User entity. type UserDeleteOne struct { - ud *UserDelete + _d *UserDelete } // Where appends a list predicates to the UserDelete builder. -func (udo *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne { - udo.ud.mutation.Where(ps...) - return udo +func (_d *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne { + _d._d.mutation.Where(ps...) + return _d } // Exec executes the deletion query. -func (udo *UserDeleteOne) Exec(ctx context.Context) error { - n, err := udo.ud.Exec(ctx) +func (_d *UserDeleteOne) Exec(ctx context.Context) error { + n, err := _d._d.Exec(ctx) switch { case err != nil: return err @@ -81,8 +81,8 @@ func (udo *UserDeleteOne) Exec(ctx context.Context) error { } // ExecX is like Exec, but panics if an error occurs. -func (udo *UserDeleteOne) ExecX(ctx context.Context) { - if err := udo.Exec(ctx); err != nil { +func (_d *UserDeleteOne) ExecX(ctx context.Context) { + if err := _d.Exec(ctx); err != nil { panic(err) } } diff --git a/ent/user_query.go b/ent/user_query.go index cf1b7fe..7aedb58 100644 --- a/ent/user_query.go +++ b/ent/user_query.go @@ -31,44 +31,44 @@ type UserQuery struct { } // Where adds a new predicate for the UserQuery builder. -func (uq *UserQuery) Where(ps ...predicate.User) *UserQuery { - uq.predicates = append(uq.predicates, ps...) - return uq +func (_q *UserQuery) Where(ps ...predicate.User) *UserQuery { + _q.predicates = append(_q.predicates, ps...) + return _q } // Limit the number of records to be returned by this query. -func (uq *UserQuery) Limit(limit int) *UserQuery { - uq.ctx.Limit = &limit - return uq +func (_q *UserQuery) Limit(limit int) *UserQuery { + _q.ctx.Limit = &limit + return _q } // Offset to start from. -func (uq *UserQuery) Offset(offset int) *UserQuery { - uq.ctx.Offset = &offset - return uq +func (_q *UserQuery) Offset(offset int) *UserQuery { + _q.ctx.Offset = &offset + return _q } // Unique configures the query builder to filter duplicate records on query. // By default, unique is set to true, and can be disabled using this method. -func (uq *UserQuery) Unique(unique bool) *UserQuery { - uq.ctx.Unique = &unique - return uq +func (_q *UserQuery) Unique(unique bool) *UserQuery { + _q.ctx.Unique = &unique + return _q } // Order specifies how the records should be ordered. -func (uq *UserQuery) Order(o ...user.OrderOption) *UserQuery { - uq.order = append(uq.order, o...) - return uq +func (_q *UserQuery) Order(o ...user.OrderOption) *UserQuery { + _q.order = append(_q.order, o...) + return _q } // QueryOwner chains the current query on the "owner" edge. -func (uq *UserQuery) QueryOwner() *PasswordTokenQuery { - query := (&PasswordTokenClient{config: uq.config}).Query() +func (_q *UserQuery) QueryOwner() *PasswordTokenQuery { + query := (&PasswordTokenClient{config: _q.config}).Query() query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { - if err := uq.prepareQuery(ctx); err != nil { + if err := _q.prepareQuery(ctx); err != nil { return nil, err } - selector := uq.sqlQuery(ctx) + selector := _q.sqlQuery(ctx) if err := selector.Err(); err != nil { return nil, err } @@ -77,7 +77,7 @@ func (uq *UserQuery) QueryOwner() *PasswordTokenQuery { sqlgraph.To(passwordtoken.Table, passwordtoken.FieldID), sqlgraph.Edge(sqlgraph.O2M, true, user.OwnerTable, user.OwnerColumn), ) - fromU = sqlgraph.SetNeighbors(uq.driver.Dialect(), step) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) return fromU, nil } return query @@ -85,8 +85,8 @@ func (uq *UserQuery) QueryOwner() *PasswordTokenQuery { // First returns the first User entity from the query. // Returns a *NotFoundError when no User was found. -func (uq *UserQuery) First(ctx context.Context) (*User, error) { - nodes, err := uq.Limit(1).All(setContextOp(ctx, uq.ctx, ent.OpQueryFirst)) +func (_q *UserQuery) First(ctx context.Context) (*User, error) { + nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst)) if err != nil { return nil, err } @@ -97,8 +97,8 @@ func (uq *UserQuery) First(ctx context.Context) (*User, error) { } // FirstX is like First, but panics if an error occurs. -func (uq *UserQuery) FirstX(ctx context.Context) *User { - node, err := uq.First(ctx) +func (_q *UserQuery) FirstX(ctx context.Context) *User { + node, err := _q.First(ctx) if err != nil && !IsNotFound(err) { panic(err) } @@ -107,9 +107,9 @@ func (uq *UserQuery) FirstX(ctx context.Context) *User { // FirstID returns the first User ID from the query. // Returns a *NotFoundError when no User ID was found. -func (uq *UserQuery) FirstID(ctx context.Context) (id int, err error) { +func (_q *UserQuery) FirstID(ctx context.Context) (id int, err error) { var ids []int - if ids, err = uq.Limit(1).IDs(setContextOp(ctx, uq.ctx, ent.OpQueryFirstID)); err != nil { + if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil { return } if len(ids) == 0 { @@ -120,8 +120,8 @@ func (uq *UserQuery) FirstID(ctx context.Context) (id int, err error) { } // FirstIDX is like FirstID, but panics if an error occurs. -func (uq *UserQuery) FirstIDX(ctx context.Context) int { - id, err := uq.FirstID(ctx) +func (_q *UserQuery) FirstIDX(ctx context.Context) int { + id, err := _q.FirstID(ctx) if err != nil && !IsNotFound(err) { panic(err) } @@ -131,8 +131,8 @@ func (uq *UserQuery) FirstIDX(ctx context.Context) int { // Only returns a single User entity found by the query, ensuring it only returns one. // Returns a *NotSingularError when more than one User entity is found. // Returns a *NotFoundError when no User entities are found. -func (uq *UserQuery) Only(ctx context.Context) (*User, error) { - nodes, err := uq.Limit(2).All(setContextOp(ctx, uq.ctx, ent.OpQueryOnly)) +func (_q *UserQuery) Only(ctx context.Context) (*User, error) { + nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly)) if err != nil { return nil, err } @@ -147,8 +147,8 @@ func (uq *UserQuery) Only(ctx context.Context) (*User, error) { } // OnlyX is like Only, but panics if an error occurs. -func (uq *UserQuery) OnlyX(ctx context.Context) *User { - node, err := uq.Only(ctx) +func (_q *UserQuery) OnlyX(ctx context.Context) *User { + node, err := _q.Only(ctx) if err != nil { panic(err) } @@ -158,9 +158,9 @@ func (uq *UserQuery) OnlyX(ctx context.Context) *User { // OnlyID is like Only, but returns the only User ID in the query. // Returns a *NotSingularError when more than one User ID is found. // Returns a *NotFoundError when no entities are found. -func (uq *UserQuery) OnlyID(ctx context.Context) (id int, err error) { +func (_q *UserQuery) OnlyID(ctx context.Context) (id int, err error) { var ids []int - if ids, err = uq.Limit(2).IDs(setContextOp(ctx, uq.ctx, ent.OpQueryOnlyID)); err != nil { + if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil { return } switch len(ids) { @@ -175,8 +175,8 @@ func (uq *UserQuery) OnlyID(ctx context.Context) (id int, err error) { } // OnlyIDX is like OnlyID, but panics if an error occurs. -func (uq *UserQuery) OnlyIDX(ctx context.Context) int { - id, err := uq.OnlyID(ctx) +func (_q *UserQuery) OnlyIDX(ctx context.Context) int { + id, err := _q.OnlyID(ctx) if err != nil { panic(err) } @@ -184,18 +184,18 @@ func (uq *UserQuery) OnlyIDX(ctx context.Context) int { } // All executes the query and returns a list of Users. -func (uq *UserQuery) All(ctx context.Context) ([]*User, error) { - ctx = setContextOp(ctx, uq.ctx, ent.OpQueryAll) - if err := uq.prepareQuery(ctx); err != nil { +func (_q *UserQuery) All(ctx context.Context) ([]*User, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll) + if err := _q.prepareQuery(ctx); err != nil { return nil, err } qr := querierAll[[]*User, *UserQuery]() - return withInterceptors[[]*User](ctx, uq, qr, uq.inters) + return withInterceptors[[]*User](ctx, _q, qr, _q.inters) } // AllX is like All, but panics if an error occurs. -func (uq *UserQuery) AllX(ctx context.Context) []*User { - nodes, err := uq.All(ctx) +func (_q *UserQuery) AllX(ctx context.Context) []*User { + nodes, err := _q.All(ctx) if err != nil { panic(err) } @@ -203,20 +203,20 @@ func (uq *UserQuery) AllX(ctx context.Context) []*User { } // IDs executes the query and returns a list of User IDs. -func (uq *UserQuery) IDs(ctx context.Context) (ids []int, err error) { - if uq.ctx.Unique == nil && uq.path != nil { - uq.Unique(true) +func (_q *UserQuery) IDs(ctx context.Context) (ids []int, err error) { + if _q.ctx.Unique == nil && _q.path != nil { + _q.Unique(true) } - ctx = setContextOp(ctx, uq.ctx, ent.OpQueryIDs) - if err = uq.Select(user.FieldID).Scan(ctx, &ids); err != nil { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs) + if err = _q.Select(user.FieldID).Scan(ctx, &ids); err != nil { return nil, err } return ids, nil } // IDsX is like IDs, but panics if an error occurs. -func (uq *UserQuery) IDsX(ctx context.Context) []int { - ids, err := uq.IDs(ctx) +func (_q *UserQuery) IDsX(ctx context.Context) []int { + ids, err := _q.IDs(ctx) if err != nil { panic(err) } @@ -224,17 +224,17 @@ func (uq *UserQuery) IDsX(ctx context.Context) []int { } // Count returns the count of the given query. -func (uq *UserQuery) Count(ctx context.Context) (int, error) { - ctx = setContextOp(ctx, uq.ctx, ent.OpQueryCount) - if err := uq.prepareQuery(ctx); err != nil { +func (_q *UserQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount) + if err := _q.prepareQuery(ctx); err != nil { return 0, err } - return withInterceptors[int](ctx, uq, querierCount[*UserQuery](), uq.inters) + return withInterceptors[int](ctx, _q, querierCount[*UserQuery](), _q.inters) } // CountX is like Count, but panics if an error occurs. -func (uq *UserQuery) CountX(ctx context.Context) int { - count, err := uq.Count(ctx) +func (_q *UserQuery) CountX(ctx context.Context) int { + count, err := _q.Count(ctx) if err != nil { panic(err) } @@ -242,9 +242,9 @@ func (uq *UserQuery) CountX(ctx context.Context) int { } // Exist returns true if the query has elements in the graph. -func (uq *UserQuery) Exist(ctx context.Context) (bool, error) { - ctx = setContextOp(ctx, uq.ctx, ent.OpQueryExist) - switch _, err := uq.FirstID(ctx); { +func (_q *UserQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist) + switch _, err := _q.FirstID(ctx); { case IsNotFound(err): return false, nil case err != nil: @@ -255,8 +255,8 @@ func (uq *UserQuery) Exist(ctx context.Context) (bool, error) { } // ExistX is like Exist, but panics if an error occurs. -func (uq *UserQuery) ExistX(ctx context.Context) bool { - exist, err := uq.Exist(ctx) +func (_q *UserQuery) ExistX(ctx context.Context) bool { + exist, err := _q.Exist(ctx) if err != nil { panic(err) } @@ -265,32 +265,32 @@ func (uq *UserQuery) ExistX(ctx context.Context) bool { // Clone returns a duplicate of the UserQuery builder, including all associated steps. It can be // used to prepare common query builders and use them differently after the clone is made. -func (uq *UserQuery) Clone() *UserQuery { - if uq == nil { +func (_q *UserQuery) Clone() *UserQuery { + if _q == nil { return nil } return &UserQuery{ - config: uq.config, - ctx: uq.ctx.Clone(), - order: append([]user.OrderOption{}, uq.order...), - inters: append([]Interceptor{}, uq.inters...), - predicates: append([]predicate.User{}, uq.predicates...), - withOwner: uq.withOwner.Clone(), + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]user.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.User{}, _q.predicates...), + withOwner: _q.withOwner.Clone(), // clone intermediate query. - sql: uq.sql.Clone(), - path: uq.path, + sql: _q.sql.Clone(), + path: _q.path, } } // WithOwner tells the query-builder to eager-load the nodes that are connected to // the "owner" edge. The optional arguments are used to configure the query builder of the edge. -func (uq *UserQuery) WithOwner(opts ...func(*PasswordTokenQuery)) *UserQuery { - query := (&PasswordTokenClient{config: uq.config}).Query() +func (_q *UserQuery) WithOwner(opts ...func(*PasswordTokenQuery)) *UserQuery { + query := (&PasswordTokenClient{config: _q.config}).Query() for _, opt := range opts { opt(query) } - uq.withOwner = query - return uq + _q.withOwner = query + return _q } // GroupBy is used to group vertices by one or more fields/columns. @@ -307,10 +307,10 @@ func (uq *UserQuery) WithOwner(opts ...func(*PasswordTokenQuery)) *UserQuery { // GroupBy(user.FieldName). // Aggregate(ent.Count()). // Scan(ctx, &v) -func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { - uq.ctx.Fields = append([]string{field}, fields...) - grbuild := &UserGroupBy{build: uq} - grbuild.flds = &uq.ctx.Fields +func (_q *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { + _q.ctx.Fields = append([]string{field}, fields...) + grbuild := &UserGroupBy{build: _q} + grbuild.flds = &_q.ctx.Fields grbuild.label = user.Label grbuild.scan = grbuild.Scan return grbuild @@ -328,58 +328,58 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { // client.User.Query(). // Select(user.FieldName). // Scan(ctx, &v) -func (uq *UserQuery) Select(fields ...string) *UserSelect { - uq.ctx.Fields = append(uq.ctx.Fields, fields...) - sbuild := &UserSelect{UserQuery: uq} +func (_q *UserQuery) Select(fields ...string) *UserSelect { + _q.ctx.Fields = append(_q.ctx.Fields, fields...) + sbuild := &UserSelect{UserQuery: _q} sbuild.label = user.Label - sbuild.flds, sbuild.scan = &uq.ctx.Fields, sbuild.Scan + sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan return sbuild } // Aggregate returns a UserSelect configured with the given aggregations. -func (uq *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect { - return uq.Select().Aggregate(fns...) +func (_q *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect { + return _q.Select().Aggregate(fns...) } -func (uq *UserQuery) prepareQuery(ctx context.Context) error { - for _, inter := range uq.inters { +func (_q *UserQuery) prepareQuery(ctx context.Context) error { + for _, inter := range _q.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, uq); err != nil { + if err := trv.Traverse(ctx, _q); err != nil { return err } } } - for _, f := range uq.ctx.Fields { + for _, f := range _q.ctx.Fields { if !user.ValidColumn(f) { return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} } } - if uq.path != nil { - prev, err := uq.path(ctx) + if _q.path != nil { + prev, err := _q.path(ctx) if err != nil { return err } - uq.sql = prev + _q.sql = prev } return nil } -func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, error) { +func (_q *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, error) { var ( nodes = []*User{} - _spec = uq.querySpec() + _spec = _q.querySpec() loadedTypes = [1]bool{ - uq.withOwner != nil, + _q.withOwner != nil, } ) _spec.ScanValues = func(columns []string) ([]any, error) { return (*User).scanValues(nil, columns) } _spec.Assign = func(columns []string, values []any) error { - node := &User{config: uq.config} + node := &User{config: _q.config} nodes = append(nodes, node) node.Edges.loadedTypes = loadedTypes return node.assignValues(columns, values) @@ -387,14 +387,14 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e for i := range hooks { hooks[i](ctx, _spec) } - if err := sqlgraph.QueryNodes(ctx, uq.driver, _spec); err != nil { + if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil { return nil, err } if len(nodes) == 0 { return nodes, nil } - if query := uq.withOwner; query != nil { - if err := uq.loadOwner(ctx, query, nodes, + if query := _q.withOwner; query != nil { + if err := _q.loadOwner(ctx, query, nodes, func(n *User) { n.Edges.Owner = []*PasswordToken{} }, func(n *User, e *PasswordToken) { n.Edges.Owner = append(n.Edges.Owner, e) }); err != nil { return nil, err @@ -403,7 +403,7 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e return nodes, nil } -func (uq *UserQuery) loadOwner(ctx context.Context, query *PasswordTokenQuery, nodes []*User, init func(*User), assign func(*User, *PasswordToken)) error { +func (_q *UserQuery) loadOwner(ctx context.Context, query *PasswordTokenQuery, nodes []*User, init func(*User), assign func(*User, *PasswordToken)) error { fks := make([]driver.Value, 0, len(nodes)) nodeids := make(map[int]*User) for i := range nodes { @@ -434,24 +434,24 @@ func (uq *UserQuery) loadOwner(ctx context.Context, query *PasswordTokenQuery, n return nil } -func (uq *UserQuery) sqlCount(ctx context.Context) (int, error) { - _spec := uq.querySpec() - _spec.Node.Columns = uq.ctx.Fields - if len(uq.ctx.Fields) > 0 { - _spec.Unique = uq.ctx.Unique != nil && *uq.ctx.Unique +func (_q *UserQuery) sqlCount(ctx context.Context) (int, error) { + _spec := _q.querySpec() + _spec.Node.Columns = _q.ctx.Fields + if len(_q.ctx.Fields) > 0 { + _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique } - return sqlgraph.CountNodes(ctx, uq.driver, _spec) + return sqlgraph.CountNodes(ctx, _q.driver, _spec) } -func (uq *UserQuery) querySpec() *sqlgraph.QuerySpec { +func (_q *UserQuery) querySpec() *sqlgraph.QuerySpec { _spec := sqlgraph.NewQuerySpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) - _spec.From = uq.sql - if unique := uq.ctx.Unique; unique != nil { + _spec.From = _q.sql + if unique := _q.ctx.Unique; unique != nil { _spec.Unique = *unique - } else if uq.path != nil { + } else if _q.path != nil { _spec.Unique = true } - if fields := uq.ctx.Fields; len(fields) > 0 { + if fields := _q.ctx.Fields; len(fields) > 0 { _spec.Node.Columns = make([]string, 0, len(fields)) _spec.Node.Columns = append(_spec.Node.Columns, user.FieldID) for i := range fields { @@ -460,20 +460,20 @@ func (uq *UserQuery) querySpec() *sqlgraph.QuerySpec { } } } - if ps := uq.predicates; len(ps) > 0 { + if ps := _q.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - if limit := uq.ctx.Limit; limit != nil { + if limit := _q.ctx.Limit; limit != nil { _spec.Limit = *limit } - if offset := uq.ctx.Offset; offset != nil { + if offset := _q.ctx.Offset; offset != nil { _spec.Offset = *offset } - if ps := uq.order; len(ps) > 0 { + if ps := _q.order; len(ps) > 0 { _spec.Order = func(selector *sql.Selector) { for i := range ps { ps[i](selector) @@ -483,33 +483,33 @@ func (uq *UserQuery) querySpec() *sqlgraph.QuerySpec { return _spec } -func (uq *UserQuery) sqlQuery(ctx context.Context) *sql.Selector { - builder := sql.Dialect(uq.driver.Dialect()) +func (_q *UserQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(_q.driver.Dialect()) t1 := builder.Table(user.Table) - columns := uq.ctx.Fields + columns := _q.ctx.Fields if len(columns) == 0 { columns = user.Columns } selector := builder.Select(t1.Columns(columns...)...).From(t1) - if uq.sql != nil { - selector = uq.sql + if _q.sql != nil { + selector = _q.sql selector.Select(selector.Columns(columns...)...) } - if uq.ctx.Unique != nil && *uq.ctx.Unique { + if _q.ctx.Unique != nil && *_q.ctx.Unique { selector.Distinct() } - for _, p := range uq.predicates { + for _, p := range _q.predicates { p(selector) } - for _, p := range uq.order { + for _, p := range _q.order { p(selector) } - if offset := uq.ctx.Offset; offset != nil { + if offset := _q.ctx.Offset; offset != nil { // limit is mandatory for offset clause. We start // with default value, and override it below if needed. selector.Offset(*offset).Limit(math.MaxInt32) } - if limit := uq.ctx.Limit; limit != nil { + if limit := _q.ctx.Limit; limit != nil { selector.Limit(*limit) } return selector @@ -522,41 +522,41 @@ type UserGroupBy struct { } // Aggregate adds the given aggregation functions to the group-by query. -func (ugb *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy { - ugb.fns = append(ugb.fns, fns...) - return ugb +func (_g *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy { + _g.fns = append(_g.fns, fns...) + return _g } // Scan applies the selector query and scans the result into the given value. -func (ugb *UserGroupBy) Scan(ctx context.Context, v any) error { - ctx = setContextOp(ctx, ugb.build.ctx, ent.OpQueryGroupBy) - if err := ugb.build.prepareQuery(ctx); err != nil { +func (_g *UserGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy) + if err := _g.build.prepareQuery(ctx); err != nil { return err } - return scanWithInterceptors[*UserQuery, *UserGroupBy](ctx, ugb.build, ugb, ugb.build.inters, v) + return scanWithInterceptors[*UserQuery, *UserGroupBy](ctx, _g.build, _g, _g.build.inters, v) } -func (ugb *UserGroupBy) sqlScan(ctx context.Context, root *UserQuery, v any) error { +func (_g *UserGroupBy) sqlScan(ctx context.Context, root *UserQuery, v any) error { selector := root.sqlQuery(ctx).Select() - aggregation := make([]string, 0, len(ugb.fns)) - for _, fn := range ugb.fns { + aggregation := make([]string, 0, len(_g.fns)) + for _, fn := range _g.fns { aggregation = append(aggregation, fn(selector)) } if len(selector.SelectedColumns()) == 0 { - columns := make([]string, 0, len(*ugb.flds)+len(ugb.fns)) - for _, f := range *ugb.flds { + columns := make([]string, 0, len(*_g.flds)+len(_g.fns)) + for _, f := range *_g.flds { columns = append(columns, selector.C(f)) } columns = append(columns, aggregation...) selector.Select(columns...) } - selector.GroupBy(selector.Columns(*ugb.flds...)...) + selector.GroupBy(selector.Columns(*_g.flds...)...) if err := selector.Err(); err != nil { return err } rows := &sql.Rows{} query, args := selector.Query() - if err := ugb.build.driver.Query(ctx, query, args, rows); err != nil { + if err := _g.build.driver.Query(ctx, query, args, rows); err != nil { return err } defer rows.Close() @@ -570,27 +570,27 @@ type UserSelect struct { } // Aggregate adds the given aggregation functions to the selector query. -func (us *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect { - us.fns = append(us.fns, fns...) - return us +func (_s *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect { + _s.fns = append(_s.fns, fns...) + return _s } // Scan applies the selector query and scans the result into the given value. -func (us *UserSelect) Scan(ctx context.Context, v any) error { - ctx = setContextOp(ctx, us.ctx, ent.OpQuerySelect) - if err := us.prepareQuery(ctx); err != nil { +func (_s *UserSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect) + if err := _s.prepareQuery(ctx); err != nil { return err } - return scanWithInterceptors[*UserQuery, *UserSelect](ctx, us.UserQuery, us, us.inters, v) + return scanWithInterceptors[*UserQuery, *UserSelect](ctx, _s.UserQuery, _s, _s.inters, v) } -func (us *UserSelect) sqlScan(ctx context.Context, root *UserQuery, v any) error { +func (_s *UserSelect) sqlScan(ctx context.Context, root *UserQuery, v any) error { selector := root.sqlQuery(ctx) - aggregation := make([]string, 0, len(us.fns)) - for _, fn := range us.fns { + aggregation := make([]string, 0, len(_s.fns)) + for _, fn := range _s.fns { aggregation = append(aggregation, fn(selector)) } - switch n := len(*us.selector.flds); { + switch n := len(*_s.selector.flds); { case n == 0 && len(aggregation) > 0: selector.Select(aggregation...) case n != 0 && len(aggregation) > 0: @@ -598,7 +598,7 @@ func (us *UserSelect) sqlScan(ctx context.Context, root *UserQuery, v any) error } rows := &sql.Rows{} query, args := selector.Query() - if err := us.driver.Query(ctx, query, args, rows); err != nil { + if err := _s.driver.Query(ctx, query, args, rows); err != nil { return err } defer rows.Close() diff --git a/ent/user_update.go b/ent/user_update.go index 23dc8a5..cda7bda 100644 --- a/ent/user_update.go +++ b/ent/user_update.go @@ -23,130 +23,130 @@ type UserUpdate struct { } // Where appends a list predicates to the UserUpdate builder. -func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate { - uu.mutation.Where(ps...) - return uu +func (_u *UserUpdate) Where(ps ...predicate.User) *UserUpdate { + _u.mutation.Where(ps...) + return _u } // SetName sets the "name" field. -func (uu *UserUpdate) SetName(s string) *UserUpdate { - uu.mutation.SetName(s) - return uu +func (_u *UserUpdate) SetName(v string) *UserUpdate { + _u.mutation.SetName(v) + return _u } // SetNillableName sets the "name" field if the given value is not nil. -func (uu *UserUpdate) SetNillableName(s *string) *UserUpdate { - if s != nil { - uu.SetName(*s) +func (_u *UserUpdate) SetNillableName(v *string) *UserUpdate { + if v != nil { + _u.SetName(*v) } - return uu + return _u } // SetEmail sets the "email" field. -func (uu *UserUpdate) SetEmail(s string) *UserUpdate { - uu.mutation.SetEmail(s) - return uu +func (_u *UserUpdate) SetEmail(v string) *UserUpdate { + _u.mutation.SetEmail(v) + return _u } // SetNillableEmail sets the "email" field if the given value is not nil. -func (uu *UserUpdate) SetNillableEmail(s *string) *UserUpdate { - if s != nil { - uu.SetEmail(*s) +func (_u *UserUpdate) SetNillableEmail(v *string) *UserUpdate { + if v != nil { + _u.SetEmail(*v) } - return uu + return _u } // SetPassword sets the "password" field. -func (uu *UserUpdate) SetPassword(s string) *UserUpdate { - uu.mutation.SetPassword(s) - return uu +func (_u *UserUpdate) SetPassword(v string) *UserUpdate { + _u.mutation.SetPassword(v) + return _u } // SetNillablePassword sets the "password" field if the given value is not nil. -func (uu *UserUpdate) SetNillablePassword(s *string) *UserUpdate { - if s != nil { - uu.SetPassword(*s) +func (_u *UserUpdate) SetNillablePassword(v *string) *UserUpdate { + if v != nil { + _u.SetPassword(*v) } - return uu + return _u } // SetVerified sets the "verified" field. -func (uu *UserUpdate) SetVerified(b bool) *UserUpdate { - uu.mutation.SetVerified(b) - return uu +func (_u *UserUpdate) SetVerified(v bool) *UserUpdate { + _u.mutation.SetVerified(v) + return _u } // SetNillableVerified sets the "verified" field if the given value is not nil. -func (uu *UserUpdate) SetNillableVerified(b *bool) *UserUpdate { - if b != nil { - uu.SetVerified(*b) +func (_u *UserUpdate) SetNillableVerified(v *bool) *UserUpdate { + if v != nil { + _u.SetVerified(*v) } - return uu + return _u } // SetAdmin sets the "admin" field. -func (uu *UserUpdate) SetAdmin(b bool) *UserUpdate { - uu.mutation.SetAdmin(b) - return uu +func (_u *UserUpdate) SetAdmin(v bool) *UserUpdate { + _u.mutation.SetAdmin(v) + return _u } // SetNillableAdmin sets the "admin" field if the given value is not nil. -func (uu *UserUpdate) SetNillableAdmin(b *bool) *UserUpdate { - if b != nil { - uu.SetAdmin(*b) +func (_u *UserUpdate) SetNillableAdmin(v *bool) *UserUpdate { + if v != nil { + _u.SetAdmin(*v) } - return uu + return _u } // AddOwnerIDs adds the "owner" edge to the PasswordToken entity by IDs. -func (uu *UserUpdate) AddOwnerIDs(ids ...int) *UserUpdate { - uu.mutation.AddOwnerIDs(ids...) - return uu +func (_u *UserUpdate) AddOwnerIDs(ids ...int) *UserUpdate { + _u.mutation.AddOwnerIDs(ids...) + return _u } // AddOwner adds the "owner" edges to the PasswordToken entity. -func (uu *UserUpdate) AddOwner(p ...*PasswordToken) *UserUpdate { - ids := make([]int, len(p)) - for i := range p { - ids[i] = p[i].ID +func (_u *UserUpdate) AddOwner(v ...*PasswordToken) *UserUpdate { + ids := make([]int, len(v)) + for i := range v { + ids[i] = v[i].ID } - return uu.AddOwnerIDs(ids...) + return _u.AddOwnerIDs(ids...) } // Mutation returns the UserMutation object of the builder. -func (uu *UserUpdate) Mutation() *UserMutation { - return uu.mutation +func (_u *UserUpdate) Mutation() *UserMutation { + return _u.mutation } // ClearOwner clears all "owner" edges to the PasswordToken entity. -func (uu *UserUpdate) ClearOwner() *UserUpdate { - uu.mutation.ClearOwner() - return uu +func (_u *UserUpdate) ClearOwner() *UserUpdate { + _u.mutation.ClearOwner() + return _u } // RemoveOwnerIDs removes the "owner" edge to PasswordToken entities by IDs. -func (uu *UserUpdate) RemoveOwnerIDs(ids ...int) *UserUpdate { - uu.mutation.RemoveOwnerIDs(ids...) - return uu +func (_u *UserUpdate) RemoveOwnerIDs(ids ...int) *UserUpdate { + _u.mutation.RemoveOwnerIDs(ids...) + return _u } // RemoveOwner removes "owner" edges to PasswordToken entities. -func (uu *UserUpdate) RemoveOwner(p ...*PasswordToken) *UserUpdate { - ids := make([]int, len(p)) - for i := range p { - ids[i] = p[i].ID +func (_u *UserUpdate) RemoveOwner(v ...*PasswordToken) *UserUpdate { + ids := make([]int, len(v)) + for i := range v { + ids[i] = v[i].ID } - return uu.RemoveOwnerIDs(ids...) + return _u.RemoveOwnerIDs(ids...) } // Save executes the query and returns the number of nodes affected by the update operation. -func (uu *UserUpdate) Save(ctx context.Context) (int, error) { - return withHooks(ctx, uu.sqlSave, uu.mutation, uu.hooks) +func (_u *UserUpdate) Save(ctx context.Context) (int, error) { + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) } // SaveX is like Save, but panics if an error occurs. -func (uu *UserUpdate) SaveX(ctx context.Context) int { - affected, err := uu.Save(ctx) +func (_u *UserUpdate) SaveX(ctx context.Context) int { + affected, err := _u.Save(ctx) if err != nil { panic(err) } @@ -154,31 +154,31 @@ func (uu *UserUpdate) SaveX(ctx context.Context) int { } // Exec executes the query. -func (uu *UserUpdate) Exec(ctx context.Context) error { - _, err := uu.Save(ctx) +func (_u *UserUpdate) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (uu *UserUpdate) ExecX(ctx context.Context) { - if err := uu.Exec(ctx); err != nil { +func (_u *UserUpdate) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { panic(err) } } // check runs all checks and user-defined validators on the builder. -func (uu *UserUpdate) check() error { - if v, ok := uu.mutation.Name(); ok { +func (_u *UserUpdate) check() error { + if v, ok := _u.mutation.Name(); ok { if err := user.NameValidator(v); err != nil { return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "User.name": %w`, err)} } } - if v, ok := uu.mutation.Email(); ok { + if v, ok := _u.mutation.Email(); ok { if err := user.EmailValidator(v); err != nil { return &ValidationError{Name: "email", err: fmt.Errorf(`ent: validator failed for field "User.email": %w`, err)} } } - if v, ok := uu.mutation.Password(); ok { + if v, ok := _u.mutation.Password(); ok { if err := user.PasswordValidator(v); err != nil { return &ValidationError{Name: "password", err: fmt.Errorf(`ent: validator failed for field "User.password": %w`, err)} } @@ -186,34 +186,34 @@ func (uu *UserUpdate) check() error { return nil } -func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { - if err := uu.check(); err != nil { - return n, err +func (_u *UserUpdate) sqlSave(ctx context.Context) (_node int, err error) { + if err := _u.check(); err != nil { + return _node, err } _spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) - if ps := uu.mutation.predicates; len(ps) > 0 { + if ps := _u.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - if value, ok := uu.mutation.Name(); ok { + if value, ok := _u.mutation.Name(); ok { _spec.SetField(user.FieldName, field.TypeString, value) } - if value, ok := uu.mutation.Email(); ok { + if value, ok := _u.mutation.Email(); ok { _spec.SetField(user.FieldEmail, field.TypeString, value) } - if value, ok := uu.mutation.Password(); ok { + if value, ok := _u.mutation.Password(); ok { _spec.SetField(user.FieldPassword, field.TypeString, value) } - if value, ok := uu.mutation.Verified(); ok { + if value, ok := _u.mutation.Verified(); ok { _spec.SetField(user.FieldVerified, field.TypeBool, value) } - if value, ok := uu.mutation.Admin(); ok { + if value, ok := _u.mutation.Admin(); ok { _spec.SetField(user.FieldAdmin, field.TypeBool, value) } - if uu.mutation.OwnerCleared() { + if _u.mutation.OwnerCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, Inverse: true, @@ -226,7 +226,7 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { } _spec.Edges.Clear = append(_spec.Edges.Clear, edge) } - if nodes := uu.mutation.RemovedOwnerIDs(); len(nodes) > 0 && !uu.mutation.OwnerCleared() { + if nodes := _u.mutation.RemovedOwnerIDs(); len(nodes) > 0 && !_u.mutation.OwnerCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, Inverse: true, @@ -242,7 +242,7 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { } _spec.Edges.Clear = append(_spec.Edges.Clear, edge) } - if nodes := uu.mutation.OwnerIDs(); len(nodes) > 0 { + if nodes := _u.mutation.OwnerIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, Inverse: true, @@ -258,7 +258,7 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { } _spec.Edges.Add = append(_spec.Edges.Add, edge) } - if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, _spec); err != nil { + if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{user.Label} } else if sqlgraph.IsConstraintError(err) { @@ -266,8 +266,8 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { } return 0, err } - uu.mutation.done = true - return n, nil + _u.mutation.done = true + return _node, nil } // UserUpdateOne is the builder for updating a single User entity. @@ -279,137 +279,137 @@ type UserUpdateOne struct { } // SetName sets the "name" field. -func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne { - uuo.mutation.SetName(s) - return uuo +func (_u *UserUpdateOne) SetName(v string) *UserUpdateOne { + _u.mutation.SetName(v) + return _u } // SetNillableName sets the "name" field if the given value is not nil. -func (uuo *UserUpdateOne) SetNillableName(s *string) *UserUpdateOne { - if s != nil { - uuo.SetName(*s) +func (_u *UserUpdateOne) SetNillableName(v *string) *UserUpdateOne { + if v != nil { + _u.SetName(*v) } - return uuo + return _u } // SetEmail sets the "email" field. -func (uuo *UserUpdateOne) SetEmail(s string) *UserUpdateOne { - uuo.mutation.SetEmail(s) - return uuo +func (_u *UserUpdateOne) SetEmail(v string) *UserUpdateOne { + _u.mutation.SetEmail(v) + return _u } // SetNillableEmail sets the "email" field if the given value is not nil. -func (uuo *UserUpdateOne) SetNillableEmail(s *string) *UserUpdateOne { - if s != nil { - uuo.SetEmail(*s) +func (_u *UserUpdateOne) SetNillableEmail(v *string) *UserUpdateOne { + if v != nil { + _u.SetEmail(*v) } - return uuo + return _u } // SetPassword sets the "password" field. -func (uuo *UserUpdateOne) SetPassword(s string) *UserUpdateOne { - uuo.mutation.SetPassword(s) - return uuo +func (_u *UserUpdateOne) SetPassword(v string) *UserUpdateOne { + _u.mutation.SetPassword(v) + return _u } // SetNillablePassword sets the "password" field if the given value is not nil. -func (uuo *UserUpdateOne) SetNillablePassword(s *string) *UserUpdateOne { - if s != nil { - uuo.SetPassword(*s) +func (_u *UserUpdateOne) SetNillablePassword(v *string) *UserUpdateOne { + if v != nil { + _u.SetPassword(*v) } - return uuo + return _u } // SetVerified sets the "verified" field. -func (uuo *UserUpdateOne) SetVerified(b bool) *UserUpdateOne { - uuo.mutation.SetVerified(b) - return uuo +func (_u *UserUpdateOne) SetVerified(v bool) *UserUpdateOne { + _u.mutation.SetVerified(v) + return _u } // SetNillableVerified sets the "verified" field if the given value is not nil. -func (uuo *UserUpdateOne) SetNillableVerified(b *bool) *UserUpdateOne { - if b != nil { - uuo.SetVerified(*b) +func (_u *UserUpdateOne) SetNillableVerified(v *bool) *UserUpdateOne { + if v != nil { + _u.SetVerified(*v) } - return uuo + return _u } // SetAdmin sets the "admin" field. -func (uuo *UserUpdateOne) SetAdmin(b bool) *UserUpdateOne { - uuo.mutation.SetAdmin(b) - return uuo +func (_u *UserUpdateOne) SetAdmin(v bool) *UserUpdateOne { + _u.mutation.SetAdmin(v) + return _u } // SetNillableAdmin sets the "admin" field if the given value is not nil. -func (uuo *UserUpdateOne) SetNillableAdmin(b *bool) *UserUpdateOne { - if b != nil { - uuo.SetAdmin(*b) +func (_u *UserUpdateOne) SetNillableAdmin(v *bool) *UserUpdateOne { + if v != nil { + _u.SetAdmin(*v) } - return uuo + return _u } // AddOwnerIDs adds the "owner" edge to the PasswordToken entity by IDs. -func (uuo *UserUpdateOne) AddOwnerIDs(ids ...int) *UserUpdateOne { - uuo.mutation.AddOwnerIDs(ids...) - return uuo +func (_u *UserUpdateOne) AddOwnerIDs(ids ...int) *UserUpdateOne { + _u.mutation.AddOwnerIDs(ids...) + return _u } // AddOwner adds the "owner" edges to the PasswordToken entity. -func (uuo *UserUpdateOne) AddOwner(p ...*PasswordToken) *UserUpdateOne { - ids := make([]int, len(p)) - for i := range p { - ids[i] = p[i].ID +func (_u *UserUpdateOne) AddOwner(v ...*PasswordToken) *UserUpdateOne { + ids := make([]int, len(v)) + for i := range v { + ids[i] = v[i].ID } - return uuo.AddOwnerIDs(ids...) + return _u.AddOwnerIDs(ids...) } // Mutation returns the UserMutation object of the builder. -func (uuo *UserUpdateOne) Mutation() *UserMutation { - return uuo.mutation +func (_u *UserUpdateOne) Mutation() *UserMutation { + return _u.mutation } // ClearOwner clears all "owner" edges to the PasswordToken entity. -func (uuo *UserUpdateOne) ClearOwner() *UserUpdateOne { - uuo.mutation.ClearOwner() - return uuo +func (_u *UserUpdateOne) ClearOwner() *UserUpdateOne { + _u.mutation.ClearOwner() + return _u } // RemoveOwnerIDs removes the "owner" edge to PasswordToken entities by IDs. -func (uuo *UserUpdateOne) RemoveOwnerIDs(ids ...int) *UserUpdateOne { - uuo.mutation.RemoveOwnerIDs(ids...) - return uuo +func (_u *UserUpdateOne) RemoveOwnerIDs(ids ...int) *UserUpdateOne { + _u.mutation.RemoveOwnerIDs(ids...) + return _u } // RemoveOwner removes "owner" edges to PasswordToken entities. -func (uuo *UserUpdateOne) RemoveOwner(p ...*PasswordToken) *UserUpdateOne { - ids := make([]int, len(p)) - for i := range p { - ids[i] = p[i].ID +func (_u *UserUpdateOne) RemoveOwner(v ...*PasswordToken) *UserUpdateOne { + ids := make([]int, len(v)) + for i := range v { + ids[i] = v[i].ID } - return uuo.RemoveOwnerIDs(ids...) + return _u.RemoveOwnerIDs(ids...) } // Where appends a list predicates to the UserUpdate builder. -func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne { - uuo.mutation.Where(ps...) - return uuo +func (_u *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne { + _u.mutation.Where(ps...) + return _u } // Select allows selecting one or more fields (columns) of the returned entity. // The default is selecting all fields defined in the entity schema. -func (uuo *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne { - uuo.fields = append([]string{field}, fields...) - return uuo +func (_u *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne { + _u.fields = append([]string{field}, fields...) + return _u } // Save executes the query and returns the updated User entity. -func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { - return withHooks(ctx, uuo.sqlSave, uuo.mutation, uuo.hooks) +func (_u *UserUpdateOne) Save(ctx context.Context) (*User, error) { + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) } // SaveX is like Save, but panics if an error occurs. -func (uuo *UserUpdateOne) SaveX(ctx context.Context) *User { - node, err := uuo.Save(ctx) +func (_u *UserUpdateOne) SaveX(ctx context.Context) *User { + node, err := _u.Save(ctx) if err != nil { panic(err) } @@ -417,31 +417,31 @@ func (uuo *UserUpdateOne) SaveX(ctx context.Context) *User { } // Exec executes the query on the entity. -func (uuo *UserUpdateOne) Exec(ctx context.Context) error { - _, err := uuo.Save(ctx) +func (_u *UserUpdateOne) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) return err } // ExecX is like Exec, but panics if an error occurs. -func (uuo *UserUpdateOne) ExecX(ctx context.Context) { - if err := uuo.Exec(ctx); err != nil { +func (_u *UserUpdateOne) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { panic(err) } } // check runs all checks and user-defined validators on the builder. -func (uuo *UserUpdateOne) check() error { - if v, ok := uuo.mutation.Name(); ok { +func (_u *UserUpdateOne) check() error { + if v, ok := _u.mutation.Name(); ok { if err := user.NameValidator(v); err != nil { return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "User.name": %w`, err)} } } - if v, ok := uuo.mutation.Email(); ok { + if v, ok := _u.mutation.Email(); ok { if err := user.EmailValidator(v); err != nil { return &ValidationError{Name: "email", err: fmt.Errorf(`ent: validator failed for field "User.email": %w`, err)} } } - if v, ok := uuo.mutation.Password(); ok { + if v, ok := _u.mutation.Password(); ok { if err := user.PasswordValidator(v); err != nil { return &ValidationError{Name: "password", err: fmt.Errorf(`ent: validator failed for field "User.password": %w`, err)} } @@ -449,17 +449,17 @@ func (uuo *UserUpdateOne) check() error { return nil } -func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) { - if err := uuo.check(); err != nil { +func (_u *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) { + if err := _u.check(); err != nil { return _node, err } _spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) - id, ok := uuo.mutation.ID() + id, ok := _u.mutation.ID() if !ok { return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "User.id" for update`)} } _spec.Node.ID.Value = id - if fields := uuo.fields; len(fields) > 0 { + if fields := _u.fields; len(fields) > 0 { _spec.Node.Columns = make([]string, 0, len(fields)) _spec.Node.Columns = append(_spec.Node.Columns, user.FieldID) for _, f := range fields { @@ -471,29 +471,29 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) } } } - if ps := uuo.mutation.predicates; len(ps) > 0 { + if ps := _u.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { for i := range ps { ps[i](selector) } } } - if value, ok := uuo.mutation.Name(); ok { + if value, ok := _u.mutation.Name(); ok { _spec.SetField(user.FieldName, field.TypeString, value) } - if value, ok := uuo.mutation.Email(); ok { + if value, ok := _u.mutation.Email(); ok { _spec.SetField(user.FieldEmail, field.TypeString, value) } - if value, ok := uuo.mutation.Password(); ok { + if value, ok := _u.mutation.Password(); ok { _spec.SetField(user.FieldPassword, field.TypeString, value) } - if value, ok := uuo.mutation.Verified(); ok { + if value, ok := _u.mutation.Verified(); ok { _spec.SetField(user.FieldVerified, field.TypeBool, value) } - if value, ok := uuo.mutation.Admin(); ok { + if value, ok := _u.mutation.Admin(); ok { _spec.SetField(user.FieldAdmin, field.TypeBool, value) } - if uuo.mutation.OwnerCleared() { + if _u.mutation.OwnerCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, Inverse: true, @@ -506,7 +506,7 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) } _spec.Edges.Clear = append(_spec.Edges.Clear, edge) } - if nodes := uuo.mutation.RemovedOwnerIDs(); len(nodes) > 0 && !uuo.mutation.OwnerCleared() { + if nodes := _u.mutation.RemovedOwnerIDs(); len(nodes) > 0 && !_u.mutation.OwnerCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, Inverse: true, @@ -522,7 +522,7 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) } _spec.Edges.Clear = append(_spec.Edges.Clear, edge) } - if nodes := uuo.mutation.OwnerIDs(); len(nodes) > 0 { + if nodes := _u.mutation.OwnerIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, Inverse: true, @@ -538,10 +538,10 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) } _spec.Edges.Add = append(_spec.Edges.Add, edge) } - _node = &User{config: uuo.config} + _node = &User{config: _u.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues - if err = sqlgraph.UpdateNode(ctx, uuo.driver, _spec); err != nil { + if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{user.Label} } else if sqlgraph.IsConstraintError(err) { @@ -549,6 +549,6 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) } return nil, err } - uuo.mutation.done = true + _u.mutation.done = true return _node, nil }