camzalewski/personal-site
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

Re-generate ent code.

Browse source
This commit is contained in:
mikestefanello 2025-08-15 09:58:39 -04:00
parent 2a853c05d6
commit 9aa6784751
13 changed files with 850 additions and 850 deletions
Download patch file Download diff file Expand all files Collapse all files

28
ent/client.go
View file

@ -262,8 +262,8 @@ func (c *PasswordTokenClient) Update() *PasswordTokenUpdate {
} }
// UpdateOne returns an update builder for the given entity. // UpdateOne returns an update builder for the given entity.
func (c *PasswordTokenClient) UpdateOne(pt *PasswordToken) *PasswordTokenUpdateOne { func (c *PasswordTokenClient) UpdateOne(_m *PasswordToken) *PasswordTokenUpdateOne {
mutation := newPasswordTokenMutation(c.config, OpUpdateOne, withPasswordToken(pt)) mutation := newPasswordTokenMutation(c.config, OpUpdateOne, withPasswordToken(_m))
return &PasswordTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} 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. // DeleteOne returns a builder for deleting the given entity.
func (c *PasswordTokenClient) DeleteOne(pt *PasswordToken) *PasswordTokenDeleteOne { func (c *PasswordTokenClient) DeleteOne(_m *PasswordToken) *PasswordTokenDeleteOne {
return c.DeleteOneID(pt.ID) return c.DeleteOneID(_m.ID)
} }
// DeleteOneID returns a builder for deleting the given entity by its 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. // 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 := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) { query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := pt.ID id := _m.ID
step := sqlgraph.NewStep( step := sqlgraph.NewStep(
sqlgraph.From(passwordtoken.Table, passwordtoken.FieldID, id), sqlgraph.From(passwordtoken.Table, passwordtoken.FieldID, id),
sqlgraph.To(user.Table, user.FieldID), sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, passwordtoken.UserTable, passwordtoken.UserColumn), 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 fromV, nil
} }
return query return query
@ -412,8 +412,8 @@ func (c *UserClient) Update() *UserUpdate {
} }
// UpdateOne returns an update builder for the given entity. // UpdateOne returns an update builder for the given entity.
func (c *UserClient) UpdateOne(u *User) *UserUpdateOne { func (c *UserClient) UpdateOne(_m *User) *UserUpdateOne {
mutation := newUserMutation(c.config, OpUpdateOne, withUser(u)) mutation := newUserMutation(c.config, OpUpdateOne, withUser(_m))
return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} 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. // DeleteOne returns a builder for deleting the given entity.
func (c *UserClient) DeleteOne(u *User) *UserDeleteOne { func (c *UserClient) DeleteOne(_m *User) *UserDeleteOne {
return c.DeleteOneID(u.ID) return c.DeleteOneID(_m.ID)
} }
// DeleteOneID returns a builder for deleting the given entity by its 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. // 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 := (&PasswordTokenClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) { query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := u.ID id := _m.ID
step := sqlgraph.NewStep( step := sqlgraph.NewStep(
sqlgraph.From(user.Table, user.FieldID, id), sqlgraph.From(user.Table, user.FieldID, id),
sqlgraph.To(passwordtoken.Table, passwordtoken.FieldID), sqlgraph.To(passwordtoken.Table, passwordtoken.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, user.OwnerTable, user.OwnerColumn), 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 fromV, nil
} }
return query return query

4
ent/ent.go
View file

@ -71,14 +71,14 @@ var (
) )
// checkColumn checks if the column exists in the given table. // 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() { initCheck.Do(func() {
columnCheck = sql.NewColumnCheck(map[string]func(string) bool{ columnCheck = sql.NewColumnCheck(map[string]func(string) bool{
passwordtoken.Table: passwordtoken.ValidColumn, passwordtoken.Table: passwordtoken.ValidColumn,
user.Table: user.ValidColumn, user.Table: user.ValidColumn,
}) })
}) })
return columnCheck(table, column) return columnCheck(t, c)
} }
// Asc applies the given fields in ASC order. // Asc applies the given fields in ASC order.

40
ent/passwordtoken.go
View file

@ -70,7 +70,7 @@ func (*PasswordToken) scanValues(columns []string) ([]any, error) {
// assignValues assigns the values that were returned from sql.Rows (after scanning) // assignValues assigns the values that were returned from sql.Rows (after scanning)
// to the PasswordToken fields. // 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 { if m, n := len(values), len(columns); m < n {
return fmt.Errorf("mismatch number of scan values: %d != %d", 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 { if !ok {
return fmt.Errorf("unexpected type %T for field id", value) return fmt.Errorf("unexpected type %T for field id", value)
} }
pt.ID = int(value.Int64) _m.ID = int(value.Int64)
case passwordtoken.FieldToken: case passwordtoken.FieldToken:
if value, ok := values[i].(*sql.NullString); !ok { if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field token", values[i]) return fmt.Errorf("unexpected type %T for field token", values[i])
} else if value.Valid { } else if value.Valid {
pt.Token = value.String _m.Token = value.String
} }
case passwordtoken.FieldUserID: case passwordtoken.FieldUserID:
if value, ok := values[i].(*sql.NullInt64); !ok { if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field user_id", values[i]) return fmt.Errorf("unexpected type %T for field user_id", values[i])
} else if value.Valid { } else if value.Valid {
pt.UserID = int(value.Int64) _m.UserID = int(value.Int64)
} }
case passwordtoken.FieldCreatedAt: case passwordtoken.FieldCreatedAt:
if value, ok := values[i].(*sql.NullTime); !ok { if value, ok := values[i].(*sql.NullTime); !ok {
return fmt.Errorf("unexpected type %T for field created_at", values[i]) return fmt.Errorf("unexpected type %T for field created_at", values[i])
} else if value.Valid { } else if value.Valid {
pt.CreatedAt = value.Time _m.CreatedAt = value.Time
} }
default: default:
pt.selectValues.Set(columns[i], values[i]) _m.selectValues.Set(columns[i], values[i])
} }
} }
return nil 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. // Value returns the ent.Value that was dynamically selected and assigned to the PasswordToken.
// This includes values selected through modifiers, order, etc. // This includes values selected through modifiers, order, etc.
func (pt *PasswordToken) Value(name string) (ent.Value, error) { func (_m *PasswordToken) Value(name string) (ent.Value, error) {
return pt.selectValues.Get(name) return _m.selectValues.Get(name)
} }
// QueryUser queries the "user" edge of the PasswordToken entity. // QueryUser queries the "user" edge of the PasswordToken entity.
func (pt *PasswordToken) QueryUser() *UserQuery { func (_m *PasswordToken) QueryUser() *UserQuery {
return NewPasswordTokenClient(pt.config).QueryUser(pt) return NewPasswordTokenClient(_m.config).QueryUser(_m)
} }
// Update returns a builder for updating this PasswordToken. // Update returns a builder for updating this PasswordToken.
// Note that you need to call PasswordToken.Unwrap() before calling this method if 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. // was returned from a transaction, and the transaction was committed or rolled back.
func (pt *PasswordToken) Update() *PasswordTokenUpdateOne { func (_m *PasswordToken) Update() *PasswordTokenUpdateOne {
return NewPasswordTokenClient(pt.config).UpdateOne(pt) return NewPasswordTokenClient(_m.config).UpdateOne(_m)
} }
// Unwrap unwraps the PasswordToken entity that was returned from a transaction after it was closed, // 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. // so that all future queries will be executed through the driver which created the transaction.
func (pt *PasswordToken) Unwrap() *PasswordToken { func (_m *PasswordToken) Unwrap() *PasswordToken {
_tx, ok := pt.config.driver.(*txDriver) _tx, ok := _m.config.driver.(*txDriver)
if !ok { if !ok {
panic("ent: PasswordToken is not a transactional entity") panic("ent: PasswordToken is not a transactional entity")
} }
pt.config.driver = _tx.drv _m.config.driver = _tx.drv
return pt return _m
} }
// String implements the fmt.Stringer. // String implements the fmt.Stringer.
func (pt *PasswordToken) String() string { func (_m *PasswordToken) String() string {
var builder strings.Builder var builder strings.Builder
builder.WriteString("PasswordToken(") builder.WriteString("PasswordToken(")
builder.WriteString(fmt.Sprintf("id=%v, ", pt.ID)) builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
builder.WriteString("token=<sensitive>") builder.WriteString("token=<sensitive>")
builder.WriteString(", ") builder.WriteString(", ")
builder.WriteString("user_id=") builder.WriteString("user_id=")
builder.WriteString(fmt.Sprintf("%v", pt.UserID)) builder.WriteString(fmt.Sprintf("%v", _m.UserID))
builder.WriteString(", ") builder.WriteString(", ")
builder.WriteString("created_at=") builder.WriteString("created_at=")
builder.WriteString(pt.CreatedAt.Format(time.ANSIC)) builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
builder.WriteByte(')') builder.WriteByte(')')
return builder.String() return builder.String()
} }

126
ent/passwordtoken_create.go
View file

@ -22,52 +22,52 @@ type PasswordTokenCreate struct {
} }
// SetToken sets the "token" field. // SetToken sets the "token" field.
func (ptc *PasswordTokenCreate) SetToken(s string) *PasswordTokenCreate { func (_c *PasswordTokenCreate) SetToken(v string) *PasswordTokenCreate {
ptc.mutation.SetToken(s) _c.mutation.SetToken(v)
return ptc return _c
} }
// SetUserID sets the "user_id" field. // SetUserID sets the "user_id" field.
func (ptc *PasswordTokenCreate) SetUserID(i int) *PasswordTokenCreate { func (_c *PasswordTokenCreate) SetUserID(v int) *PasswordTokenCreate {
ptc.mutation.SetUserID(i) _c.mutation.SetUserID(v)
return ptc return _c
} }
// SetCreatedAt sets the "created_at" field. // SetCreatedAt sets the "created_at" field.
func (ptc *PasswordTokenCreate) SetCreatedAt(t time.Time) *PasswordTokenCreate { func (_c *PasswordTokenCreate) SetCreatedAt(v time.Time) *PasswordTokenCreate {
ptc.mutation.SetCreatedAt(t) _c.mutation.SetCreatedAt(v)
return ptc return _c
} }
// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
func (ptc *PasswordTokenCreate) SetNillableCreatedAt(t *time.Time) *PasswordTokenCreate { func (_c *PasswordTokenCreate) SetNillableCreatedAt(v *time.Time) *PasswordTokenCreate {
if t != nil { if v != nil {
ptc.SetCreatedAt(*t) _c.SetCreatedAt(*v)
} }
return ptc return _c
} }
// SetUser sets the "user" edge to the User entity. // SetUser sets the "user" edge to the User entity.
func (ptc *PasswordTokenCreate) SetUser(u *User) *PasswordTokenCreate { func (_c *PasswordTokenCreate) SetUser(v *User) *PasswordTokenCreate {
return ptc.SetUserID(u.ID) return _c.SetUserID(v.ID)
} }
// Mutation returns the PasswordTokenMutation object of the builder. // Mutation returns the PasswordTokenMutation object of the builder.
func (ptc *PasswordTokenCreate) Mutation() *PasswordTokenMutation { func (_c *PasswordTokenCreate) Mutation() *PasswordTokenMutation {
return ptc.mutation return _c.mutation
} }
// Save creates the PasswordToken in the database. // Save creates the PasswordToken in the database.
func (ptc *PasswordTokenCreate) Save(ctx context.Context) (*PasswordToken, error) { func (_c *PasswordTokenCreate) Save(ctx context.Context) (*PasswordToken, error) {
if err := ptc.defaults(); err != nil { if err := _c.defaults(); err != nil {
return nil, err 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. // SaveX calls Save and panics if Save returns an error.
func (ptc *PasswordTokenCreate) SaveX(ctx context.Context) *PasswordToken { func (_c *PasswordTokenCreate) SaveX(ctx context.Context) *PasswordToken {
v, err := ptc.Save(ctx) v, err := _c.Save(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -75,58 +75,58 @@ func (ptc *PasswordTokenCreate) SaveX(ctx context.Context) *PasswordToken {
} }
// Exec executes the query. // Exec executes the query.
func (ptc *PasswordTokenCreate) Exec(ctx context.Context) error { func (_c *PasswordTokenCreate) Exec(ctx context.Context) error {
_, err := ptc.Save(ctx) _, err := _c.Save(ctx)
return err return err
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (ptc *PasswordTokenCreate) ExecX(ctx context.Context) { func (_c *PasswordTokenCreate) ExecX(ctx context.Context) {
if err := ptc.Exec(ctx); err != nil { if err := _c.Exec(ctx); err != nil {
panic(err) panic(err)
} }
} }
// defaults sets the default values of the builder before save. // defaults sets the default values of the builder before save.
func (ptc *PasswordTokenCreate) defaults() error { func (_c *PasswordTokenCreate) defaults() error {
if _, ok := ptc.mutation.CreatedAt(); !ok { if _, ok := _c.mutation.CreatedAt(); !ok {
if passwordtoken.DefaultCreatedAt == nil { if passwordtoken.DefaultCreatedAt == nil {
return fmt.Errorf("ent: uninitialized passwordtoken.DefaultCreatedAt (forgotten import ent/runtime?)") return fmt.Errorf("ent: uninitialized passwordtoken.DefaultCreatedAt (forgotten import ent/runtime?)")
} }
v := passwordtoken.DefaultCreatedAt() v := passwordtoken.DefaultCreatedAt()
ptc.mutation.SetCreatedAt(v) _c.mutation.SetCreatedAt(v)
} }
return nil return nil
} }
// check runs all checks and user-defined validators on the builder. // check runs all checks and user-defined validators on the builder.
func (ptc *PasswordTokenCreate) check() error { func (_c *PasswordTokenCreate) check() error {
if _, ok := ptc.mutation.Token(); !ok { if _, ok := _c.mutation.Token(); !ok {
return &ValidationError{Name: "token", err: errors.New(`ent: missing required field "PasswordToken.token"`)} 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 { if err := passwordtoken.TokenValidator(v); err != nil {
return &ValidationError{Name: "token", err: fmt.Errorf(`ent: validator failed for field "PasswordToken.token": %w`, err)} 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"`)} 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"`)} 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 &ValidationError{Name: "user", err: errors.New(`ent: missing required edge "PasswordToken.user"`)}
} }
return nil return nil
} }
func (ptc *PasswordTokenCreate) sqlSave(ctx context.Context) (*PasswordToken, error) { func (_c *PasswordTokenCreate) sqlSave(ctx context.Context) (*PasswordToken, error) {
if err := ptc.check(); err != nil { if err := _c.check(); err != nil {
return nil, err return nil, err
} }
_node, _spec := ptc.createSpec() _node, _spec := _c.createSpec()
if err := sqlgraph.CreateNode(ctx, ptc.driver, _spec); err != nil { if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil {
if sqlgraph.IsConstraintError(err) { if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: 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) id := _spec.ID.Value.(int64)
_node.ID = int(id) _node.ID = int(id)
ptc.mutation.id = &_node.ID _c.mutation.id = &_node.ID
ptc.mutation.done = true _c.mutation.done = true
return _node, nil return _node, nil
} }
func (ptc *PasswordTokenCreate) createSpec() (*PasswordToken, *sqlgraph.CreateSpec) { func (_c *PasswordTokenCreate) createSpec() (*PasswordToken, *sqlgraph.CreateSpec) {
var ( var (
_node = &PasswordToken{config: ptc.config} _node = &PasswordToken{config: _c.config}
_spec = sqlgraph.NewCreateSpec(passwordtoken.Table, sqlgraph.NewFieldSpec(passwordtoken.FieldID, field.TypeInt)) _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) _spec.SetField(passwordtoken.FieldToken, field.TypeString, value)
_node.Token = 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) _spec.SetField(passwordtoken.FieldCreatedAt, field.TypeTime, value)
_node.CreatedAt = value _node.CreatedAt = value
} }
if nodes := ptc.mutation.UserIDs(); len(nodes) > 0 { if nodes := _c.mutation.UserIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O, Rel: sqlgraph.M2O,
Inverse: false, Inverse: false,
@ -180,16 +180,16 @@ type PasswordTokenCreateBulk struct {
} }
// Save creates the PasswordToken entities in the database. // Save creates the PasswordToken entities in the database.
func (ptcb *PasswordTokenCreateBulk) Save(ctx context.Context) ([]*PasswordToken, error) { func (_c *PasswordTokenCreateBulk) Save(ctx context.Context) ([]*PasswordToken, error) {
if ptcb.err != nil { if _c.err != nil {
return nil, ptcb.err return nil, _c.err
} }
specs := make([]*sqlgraph.CreateSpec, len(ptcb.builders)) specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
nodes := make([]*PasswordToken, len(ptcb.builders)) nodes := make([]*PasswordToken, len(_c.builders))
mutators := make([]Mutator, len(ptcb.builders)) mutators := make([]Mutator, len(_c.builders))
for i := range ptcb.builders { for i := range _c.builders {
func(i int, root context.Context) { func(i int, root context.Context) {
builder := ptcb.builders[i] builder := _c.builders[i]
builder.defaults() builder.defaults()
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
mutation, ok := m.(*PasswordTokenMutation) mutation, ok := m.(*PasswordTokenMutation)
@ -203,11 +203,11 @@ func (ptcb *PasswordTokenCreateBulk) Save(ctx context.Context) ([]*PasswordToken
var err error var err error
nodes[i], specs[i] = builder.createSpec() nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 { 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 { } else {
spec := &sqlgraph.BatchCreateSpec{Nodes: specs} spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
// Invoke the actual operation on the latest mutation in the chain. // 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) { if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err} err = &ConstraintError{msg: err.Error(), wrap: err}
} }
@ -231,7 +231,7 @@ func (ptcb *PasswordTokenCreateBulk) Save(ctx context.Context) ([]*PasswordToken
}(i, ctx) }(i, ctx)
} }
if len(mutators) > 0 { 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 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. // SaveX is like Save, but panics if an error occurs.
func (ptcb *PasswordTokenCreateBulk) SaveX(ctx context.Context) []*PasswordToken { func (_c *PasswordTokenCreateBulk) SaveX(ctx context.Context) []*PasswordToken {
v, err := ptcb.Save(ctx) v, err := _c.Save(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -248,14 +248,14 @@ func (ptcb *PasswordTokenCreateBulk) SaveX(ctx context.Context) []*PasswordToken
} }
// Exec executes the query. // Exec executes the query.
func (ptcb *PasswordTokenCreateBulk) Exec(ctx context.Context) error { func (_c *PasswordTokenCreateBulk) Exec(ctx context.Context) error {
_, err := ptcb.Save(ctx) _, err := _c.Save(ctx)
return err return err
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (ptcb *PasswordTokenCreateBulk) ExecX(ctx context.Context) { func (_c *PasswordTokenCreateBulk) ExecX(ctx context.Context) {
if err := ptcb.Exec(ctx); err != nil { if err := _c.Exec(ctx); err != nil {
panic(err) panic(err)
} }
} }

38
ent/passwordtoken_delete.go
View file

@ -20,56 +20,56 @@ type PasswordTokenDelete struct {
} }
// Where appends a list predicates to the PasswordTokenDelete builder. // Where appends a list predicates to the PasswordTokenDelete builder.
func (ptd *PasswordTokenDelete) Where(ps ...predicate.PasswordToken) *PasswordTokenDelete { func (_d *PasswordTokenDelete) Where(ps ...predicate.PasswordToken) *PasswordTokenDelete {
ptd.mutation.Where(ps...) _d.mutation.Where(ps...)
return ptd return _d
} }
// Exec executes the deletion query and returns how many vertices were deleted. // Exec executes the deletion query and returns how many vertices were deleted.
func (ptd *PasswordTokenDelete) Exec(ctx context.Context) (int, error) { func (_d *PasswordTokenDelete) Exec(ctx context.Context) (int, error) {
return withHooks(ctx, ptd.sqlExec, ptd.mutation, ptd.hooks) return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (ptd *PasswordTokenDelete) ExecX(ctx context.Context) int { func (_d *PasswordTokenDelete) ExecX(ctx context.Context) int {
n, err := ptd.Exec(ctx) n, err := _d.Exec(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
return n 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)) _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) { _spec.Predicate = func(selector *sql.Selector) {
for i := range ps { for i := range ps {
ps[i](selector) 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) { if err != nil && sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err} err = &ConstraintError{msg: err.Error(), wrap: err}
} }
ptd.mutation.done = true _d.mutation.done = true
return affected, err return affected, err
} }
// PasswordTokenDeleteOne is the builder for deleting a single PasswordToken entity. // PasswordTokenDeleteOne is the builder for deleting a single PasswordToken entity.
type PasswordTokenDeleteOne struct { type PasswordTokenDeleteOne struct {
ptd *PasswordTokenDelete _d *PasswordTokenDelete
} }
// Where appends a list predicates to the PasswordTokenDelete builder. // Where appends a list predicates to the PasswordTokenDelete builder.
func (ptdo *PasswordTokenDeleteOne) Where(ps ...predicate.PasswordToken) *PasswordTokenDeleteOne { func (_d *PasswordTokenDeleteOne) Where(ps ...predicate.PasswordToken) *PasswordTokenDeleteOne {
ptdo.ptd.mutation.Where(ps...) _d._d.mutation.Where(ps...)
return ptdo return _d
} }
// Exec executes the deletion query. // Exec executes the deletion query.
func (ptdo *PasswordTokenDeleteOne) Exec(ctx context.Context) error { func (_d *PasswordTokenDeleteOne) Exec(ctx context.Context) error {
n, err := ptdo.ptd.Exec(ctx) n, err := _d._d.Exec(ctx)
switch { switch {
case err != nil: case err != nil:
return err return err
@ -81,8 +81,8 @@ func (ptdo *PasswordTokenDeleteOne) Exec(ctx context.Context) error {
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (ptdo *PasswordTokenDeleteOne) ExecX(ctx context.Context) { func (_d *PasswordTokenDeleteOne) ExecX(ctx context.Context) {
if err := ptdo.Exec(ctx); err != nil { if err := _d.Exec(ctx); err != nil {
panic(err) panic(err)
} }
} }

302
ent/passwordtoken_query.go
View file

@ -30,44 +30,44 @@ type PasswordTokenQuery struct {
} }
// Where adds a new predicate for the PasswordTokenQuery builder. // Where adds a new predicate for the PasswordTokenQuery builder.
func (ptq *PasswordTokenQuery) Where(ps ...predicate.PasswordToken) *PasswordTokenQuery { func (_q *PasswordTokenQuery) Where(ps ...predicate.PasswordToken) *PasswordTokenQuery {
ptq.predicates = append(ptq.predicates, ps...) _q.predicates = append(_q.predicates, ps...)
return ptq return _q
} }
// Limit the number of records to be returned by this query. // Limit the number of records to be returned by this query.
func (ptq *PasswordTokenQuery) Limit(limit int) *PasswordTokenQuery { func (_q *PasswordTokenQuery) Limit(limit int) *PasswordTokenQuery {
ptq.ctx.Limit = &limit _q.ctx.Limit = &limit
return ptq return _q
} }
// Offset to start from. // Offset to start from.
func (ptq *PasswordTokenQuery) Offset(offset int) *PasswordTokenQuery { func (_q *PasswordTokenQuery) Offset(offset int) *PasswordTokenQuery {
ptq.ctx.Offset = &offset _q.ctx.Offset = &offset
return ptq return _q
} }
// Unique configures the query builder to filter duplicate records on query. // 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. // By default, unique is set to true, and can be disabled using this method.
func (ptq *PasswordTokenQuery) Unique(unique bool) *PasswordTokenQuery { func (_q *PasswordTokenQuery) Unique(unique bool) *PasswordTokenQuery {
ptq.ctx.Unique = &unique _q.ctx.Unique = &unique
return ptq return _q
} }
// Order specifies how the records should be ordered. // Order specifies how the records should be ordered.
func (ptq *PasswordTokenQuery) Order(o ...passwordtoken.OrderOption) *PasswordTokenQuery { func (_q *PasswordTokenQuery) Order(o ...passwordtoken.OrderOption) *PasswordTokenQuery {
ptq.order = append(ptq.order, o...) _q.order = append(_q.order, o...)
return ptq return _q
} }
// QueryUser chains the current query on the "user" edge. // QueryUser chains the current query on the "user" edge.
func (ptq *PasswordTokenQuery) QueryUser() *UserQuery { func (_q *PasswordTokenQuery) QueryUser() *UserQuery {
query := (&UserClient{config: ptq.config}).Query() query := (&UserClient{config: _q.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { 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 return nil, err
} }
selector := ptq.sqlQuery(ctx) selector := _q.sqlQuery(ctx)
if err := selector.Err(); err != nil { if err := selector.Err(); err != nil {
return nil, err return nil, err
} }
@ -76,7 +76,7 @@ func (ptq *PasswordTokenQuery) QueryUser() *UserQuery {
sqlgraph.To(user.Table, user.FieldID), sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, passwordtoken.UserTable, passwordtoken.UserColumn), 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 fromU, nil
} }
return query return query
@ -84,8 +84,8 @@ func (ptq *PasswordTokenQuery) QueryUser() *UserQuery {
// First returns the first PasswordToken entity from the query. // First returns the first PasswordToken entity from the query.
// Returns a *NotFoundError when no PasswordToken was found. // Returns a *NotFoundError when no PasswordToken was found.
func (ptq *PasswordTokenQuery) First(ctx context.Context) (*PasswordToken, error) { func (_q *PasswordTokenQuery) First(ctx context.Context) (*PasswordToken, error) {
nodes, err := ptq.Limit(1).All(setContextOp(ctx, ptq.ctx, ent.OpQueryFirst)) nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
if err != nil { if err != nil {
return nil, err 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. // FirstX is like First, but panics if an error occurs.
func (ptq *PasswordTokenQuery) FirstX(ctx context.Context) *PasswordToken { func (_q *PasswordTokenQuery) FirstX(ctx context.Context) *PasswordToken {
node, err := ptq.First(ctx) node, err := _q.First(ctx)
if err != nil && !IsNotFound(err) { if err != nil && !IsNotFound(err) {
panic(err) panic(err)
} }
@ -106,9 +106,9 @@ func (ptq *PasswordTokenQuery) FirstX(ctx context.Context) *PasswordToken {
// FirstID returns the first PasswordToken ID from the query. // FirstID returns the first PasswordToken ID from the query.
// Returns a *NotFoundError when no PasswordToken ID was found. // 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 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 return
} }
if len(ids) == 0 { 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. // FirstIDX is like FirstID, but panics if an error occurs.
func (ptq *PasswordTokenQuery) FirstIDX(ctx context.Context) int { func (_q *PasswordTokenQuery) FirstIDX(ctx context.Context) int {
id, err := ptq.FirstID(ctx) id, err := _q.FirstID(ctx)
if err != nil && !IsNotFound(err) { if err != nil && !IsNotFound(err) {
panic(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. // 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 *NotSingularError when more than one PasswordToken entity is found.
// Returns a *NotFoundError when no PasswordToken entities are found. // Returns a *NotFoundError when no PasswordToken entities are found.
func (ptq *PasswordTokenQuery) Only(ctx context.Context) (*PasswordToken, error) { func (_q *PasswordTokenQuery) Only(ctx context.Context) (*PasswordToken, error) {
nodes, err := ptq.Limit(2).All(setContextOp(ctx, ptq.ctx, ent.OpQueryOnly)) nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
if err != nil { if err != nil {
return nil, err 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. // OnlyX is like Only, but panics if an error occurs.
func (ptq *PasswordTokenQuery) OnlyX(ctx context.Context) *PasswordToken { func (_q *PasswordTokenQuery) OnlyX(ctx context.Context) *PasswordToken {
node, err := ptq.Only(ctx) node, err := _q.Only(ctx)
if err != nil { if err != nil {
panic(err) 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. // 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 *NotSingularError when more than one PasswordToken ID is found.
// Returns a *NotFoundError when no entities are 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 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 return
} }
switch len(ids) { 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. // OnlyIDX is like OnlyID, but panics if an error occurs.
func (ptq *PasswordTokenQuery) OnlyIDX(ctx context.Context) int { func (_q *PasswordTokenQuery) OnlyIDX(ctx context.Context) int {
id, err := ptq.OnlyID(ctx) id, err := _q.OnlyID(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -183,18 +183,18 @@ func (ptq *PasswordTokenQuery) OnlyIDX(ctx context.Context) int {
} }
// All executes the query and returns a list of PasswordTokens. // All executes the query and returns a list of PasswordTokens.
func (ptq *PasswordTokenQuery) All(ctx context.Context) ([]*PasswordToken, error) { func (_q *PasswordTokenQuery) All(ctx context.Context) ([]*PasswordToken, error) {
ctx = setContextOp(ctx, ptq.ctx, ent.OpQueryAll) ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
if err := ptq.prepareQuery(ctx); err != nil { if err := _q.prepareQuery(ctx); err != nil {
return nil, err return nil, err
} }
qr := querierAll[[]*PasswordToken, *PasswordTokenQuery]() 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. // AllX is like All, but panics if an error occurs.
func (ptq *PasswordTokenQuery) AllX(ctx context.Context) []*PasswordToken { func (_q *PasswordTokenQuery) AllX(ctx context.Context) []*PasswordToken {
nodes, err := ptq.All(ctx) nodes, err := _q.All(ctx)
if err != nil { if err != nil {
panic(err) 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. // IDs executes the query and returns a list of PasswordToken IDs.
func (ptq *PasswordTokenQuery) IDs(ctx context.Context) (ids []int, err error) { func (_q *PasswordTokenQuery) IDs(ctx context.Context) (ids []int, err error) {
if ptq.ctx.Unique == nil && ptq.path != nil { if _q.ctx.Unique == nil && _q.path != nil {
ptq.Unique(true) _q.Unique(true)
} }
ctx = setContextOp(ctx, ptq.ctx, ent.OpQueryIDs) ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
if err = ptq.Select(passwordtoken.FieldID).Scan(ctx, &ids); err != nil { if err = _q.Select(passwordtoken.FieldID).Scan(ctx, &ids); err != nil {
return nil, err return nil, err
} }
return ids, nil return ids, nil
} }
// IDsX is like IDs, but panics if an error occurs. // IDsX is like IDs, but panics if an error occurs.
func (ptq *PasswordTokenQuery) IDsX(ctx context.Context) []int { func (_q *PasswordTokenQuery) IDsX(ctx context.Context) []int {
ids, err := ptq.IDs(ctx) ids, err := _q.IDs(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -223,17 +223,17 @@ func (ptq *PasswordTokenQuery) IDsX(ctx context.Context) []int {
} }
// Count returns the count of the given query. // Count returns the count of the given query.
func (ptq *PasswordTokenQuery) Count(ctx context.Context) (int, error) { func (_q *PasswordTokenQuery) Count(ctx context.Context) (int, error) {
ctx = setContextOp(ctx, ptq.ctx, ent.OpQueryCount) ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
if err := ptq.prepareQuery(ctx); err != nil { if err := _q.prepareQuery(ctx); err != nil {
return 0, err 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. // CountX is like Count, but panics if an error occurs.
func (ptq *PasswordTokenQuery) CountX(ctx context.Context) int { func (_q *PasswordTokenQuery) CountX(ctx context.Context) int {
count, err := ptq.Count(ctx) count, err := _q.Count(ctx)
if err != nil { if err != nil {
panic(err) 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. // Exist returns true if the query has elements in the graph.
func (ptq *PasswordTokenQuery) Exist(ctx context.Context) (bool, error) { func (_q *PasswordTokenQuery) Exist(ctx context.Context) (bool, error) {
ctx = setContextOp(ctx, ptq.ctx, ent.OpQueryExist) ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
switch _, err := ptq.FirstID(ctx); { switch _, err := _q.FirstID(ctx); {
case IsNotFound(err): case IsNotFound(err):
return false, nil return false, nil
case err != 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. // ExistX is like Exist, but panics if an error occurs.
func (ptq *PasswordTokenQuery) ExistX(ctx context.Context) bool { func (_q *PasswordTokenQuery) ExistX(ctx context.Context) bool {
exist, err := ptq.Exist(ctx) exist, err := _q.Exist(ctx)
if err != nil { if err != nil {
panic(err) 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 // 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. // used to prepare common query builders and use them differently after the clone is made.
func (ptq *PasswordTokenQuery) Clone() *PasswordTokenQuery { func (_q *PasswordTokenQuery) Clone() *PasswordTokenQuery {
if ptq == nil { if _q == nil {
return nil return nil
} }
return &PasswordTokenQuery{ return &PasswordTokenQuery{
config: ptq.config, config: _q.config,
ctx: ptq.ctx.Clone(), ctx: _q.ctx.Clone(),
order: append([]passwordtoken.OrderOption{}, ptq.order...), order: append([]passwordtoken.OrderOption{}, _q.order...),
inters: append([]Interceptor{}, ptq.inters...), inters: append([]Interceptor{}, _q.inters...),
predicates: append([]predicate.PasswordToken{}, ptq.predicates...), predicates: append([]predicate.PasswordToken{}, _q.predicates...),
withUser: ptq.withUser.Clone(), withUser: _q.withUser.Clone(),
// clone intermediate query. // clone intermediate query.
sql: ptq.sql.Clone(), sql: _q.sql.Clone(),
path: ptq.path, path: _q.path,
} }
} }
// WithUser tells the query-builder to eager-load the nodes that are connected to // 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. // the "user" edge. The optional arguments are used to configure the query builder of the edge.
func (ptq *PasswordTokenQuery) WithUser(opts ...func(*UserQuery)) *PasswordTokenQuery { func (_q *PasswordTokenQuery) WithUser(opts ...func(*UserQuery)) *PasswordTokenQuery {
query := (&UserClient{config: ptq.config}).Query() query := (&UserClient{config: _q.config}).Query()
for _, opt := range opts { for _, opt := range opts {
opt(query) opt(query)
} }
ptq.withUser = query _q.withUser = query
return ptq return _q
} }
// GroupBy is used to group vertices by one or more fields/columns. // 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). // GroupBy(passwordtoken.FieldToken).
// Aggregate(ent.Count()). // Aggregate(ent.Count()).
// Scan(ctx, &v) // Scan(ctx, &v)
func (ptq *PasswordTokenQuery) GroupBy(field string, fields ...string) *PasswordTokenGroupBy { func (_q *PasswordTokenQuery) GroupBy(field string, fields ...string) *PasswordTokenGroupBy {
ptq.ctx.Fields = append([]string{field}, fields...) _q.ctx.Fields = append([]string{field}, fields...)
grbuild := &PasswordTokenGroupBy{build: ptq} grbuild := &PasswordTokenGroupBy{build: _q}
grbuild.flds = &ptq.ctx.Fields grbuild.flds = &_q.ctx.Fields
grbuild.label = passwordtoken.Label grbuild.label = passwordtoken.Label
grbuild.scan = grbuild.Scan grbuild.scan = grbuild.Scan
return grbuild return grbuild
@ -327,58 +327,58 @@ func (ptq *PasswordTokenQuery) GroupBy(field string, fields ...string) *Password
// client.PasswordToken.Query(). // client.PasswordToken.Query().
// Select(passwordtoken.FieldToken). // Select(passwordtoken.FieldToken).
// Scan(ctx, &v) // Scan(ctx, &v)
func (ptq *PasswordTokenQuery) Select(fields ...string) *PasswordTokenSelect { func (_q *PasswordTokenQuery) Select(fields ...string) *PasswordTokenSelect {
ptq.ctx.Fields = append(ptq.ctx.Fields, fields...) _q.ctx.Fields = append(_q.ctx.Fields, fields...)
sbuild := &PasswordTokenSelect{PasswordTokenQuery: ptq} sbuild := &PasswordTokenSelect{PasswordTokenQuery: _q}
sbuild.label = passwordtoken.Label sbuild.label = passwordtoken.Label
sbuild.flds, sbuild.scan = &ptq.ctx.Fields, sbuild.Scan sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
return sbuild return sbuild
} }
// Aggregate returns a PasswordTokenSelect configured with the given aggregations. // Aggregate returns a PasswordTokenSelect configured with the given aggregations.
func (ptq *PasswordTokenQuery) Aggregate(fns ...AggregateFunc) *PasswordTokenSelect { func (_q *PasswordTokenQuery) Aggregate(fns ...AggregateFunc) *PasswordTokenSelect {
return ptq.Select().Aggregate(fns...) return _q.Select().Aggregate(fns...)
} }
func (ptq *PasswordTokenQuery) prepareQuery(ctx context.Context) error { func (_q *PasswordTokenQuery) prepareQuery(ctx context.Context) error {
for _, inter := range ptq.inters { for _, inter := range _q.inters {
if inter == nil { if inter == nil {
return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)") return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
} }
if trv, ok := inter.(Traverser); ok { if trv, ok := inter.(Traverser); ok {
if err := trv.Traverse(ctx, ptq); err != nil { if err := trv.Traverse(ctx, _q); err != nil {
return err return err
} }
} }
} }
for _, f := range ptq.ctx.Fields { for _, f := range _q.ctx.Fields {
if !passwordtoken.ValidColumn(f) { if !passwordtoken.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
} }
} }
if ptq.path != nil { if _q.path != nil {
prev, err := ptq.path(ctx) prev, err := _q.path(ctx)
if err != nil { if err != nil {
return err return err
} }
ptq.sql = prev _q.sql = prev
} }
return nil 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 ( var (
nodes = []*PasswordToken{} nodes = []*PasswordToken{}
_spec = ptq.querySpec() _spec = _q.querySpec()
loadedTypes = [1]bool{ loadedTypes = [1]bool{
ptq.withUser != nil, _q.withUser != nil,
} }
) )
_spec.ScanValues = func(columns []string) ([]any, error) { _spec.ScanValues = func(columns []string) ([]any, error) {
return (*PasswordToken).scanValues(nil, columns) return (*PasswordToken).scanValues(nil, columns)
} }
_spec.Assign = func(columns []string, values []any) error { _spec.Assign = func(columns []string, values []any) error {
node := &PasswordToken{config: ptq.config} node := &PasswordToken{config: _q.config}
nodes = append(nodes, node) nodes = append(nodes, node)
node.Edges.loadedTypes = loadedTypes node.Edges.loadedTypes = loadedTypes
return node.assignValues(columns, values) return node.assignValues(columns, values)
@ -386,14 +386,14 @@ func (ptq *PasswordTokenQuery) sqlAll(ctx context.Context, hooks ...queryHook) (
for i := range hooks { for i := range hooks {
hooks[i](ctx, _spec) 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 return nil, err
} }
if len(nodes) == 0 { if len(nodes) == 0 {
return nodes, nil return nodes, nil
} }
if query := ptq.withUser; query != nil { if query := _q.withUser; query != nil {
if err := ptq.loadUser(ctx, query, nodes, nil, if err := _q.loadUser(ctx, query, nodes, nil,
func(n *PasswordToken, e *User) { n.Edges.User = e }); err != nil { func(n *PasswordToken, e *User) { n.Edges.User = e }); err != nil {
return nil, err return nil, err
} }
@ -401,7 +401,7 @@ func (ptq *PasswordTokenQuery) sqlAll(ctx context.Context, hooks ...queryHook) (
return nodes, nil 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)) ids := make([]int, 0, len(nodes))
nodeids := make(map[int][]*PasswordToken) nodeids := make(map[int][]*PasswordToken)
for i := range nodes { for i := range nodes {
@ -431,24 +431,24 @@ func (ptq *PasswordTokenQuery) loadUser(ctx context.Context, query *UserQuery, n
return nil return nil
} }
func (ptq *PasswordTokenQuery) sqlCount(ctx context.Context) (int, error) { func (_q *PasswordTokenQuery) sqlCount(ctx context.Context) (int, error) {
_spec := ptq.querySpec() _spec := _q.querySpec()
_spec.Node.Columns = ptq.ctx.Fields _spec.Node.Columns = _q.ctx.Fields
if len(ptq.ctx.Fields) > 0 { if len(_q.ctx.Fields) > 0 {
_spec.Unique = ptq.ctx.Unique != nil && *ptq.ctx.Unique _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 := sqlgraph.NewQuerySpec(passwordtoken.Table, passwordtoken.Columns, sqlgraph.NewFieldSpec(passwordtoken.FieldID, field.TypeInt))
_spec.From = ptq.sql _spec.From = _q.sql
if unique := ptq.ctx.Unique; unique != nil { if unique := _q.ctx.Unique; unique != nil {
_spec.Unique = *unique _spec.Unique = *unique
} else if ptq.path != nil { } else if _q.path != nil {
_spec.Unique = true _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 = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, passwordtoken.FieldID) _spec.Node.Columns = append(_spec.Node.Columns, passwordtoken.FieldID)
for i := range fields { for i := range fields {
@ -456,24 +456,24 @@ func (ptq *PasswordTokenQuery) querySpec() *sqlgraph.QuerySpec {
_spec.Node.Columns = append(_spec.Node.Columns, fields[i]) _spec.Node.Columns = append(_spec.Node.Columns, fields[i])
} }
} }
if ptq.withUser != nil { if _q.withUser != nil {
_spec.Node.AddColumnOnce(passwordtoken.FieldUserID) _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) { _spec.Predicate = func(selector *sql.Selector) {
for i := range ps { for i := range ps {
ps[i](selector) ps[i](selector)
} }
} }
} }
if limit := ptq.ctx.Limit; limit != nil { if limit := _q.ctx.Limit; limit != nil {
_spec.Limit = *limit _spec.Limit = *limit
} }
if offset := ptq.ctx.Offset; offset != nil { if offset := _q.ctx.Offset; offset != nil {
_spec.Offset = *offset _spec.Offset = *offset
} }
if ps := ptq.order; len(ps) > 0 { if ps := _q.order; len(ps) > 0 {
_spec.Order = func(selector *sql.Selector) { _spec.Order = func(selector *sql.Selector) {
for i := range ps { for i := range ps {
ps[i](selector) ps[i](selector)
@ -483,33 +483,33 @@ func (ptq *PasswordTokenQuery) querySpec() *sqlgraph.QuerySpec {
return _spec return _spec
} }
func (ptq *PasswordTokenQuery) sqlQuery(ctx context.Context) *sql.Selector { func (_q *PasswordTokenQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(ptq.driver.Dialect()) builder := sql.Dialect(_q.driver.Dialect())
t1 := builder.Table(passwordtoken.Table) t1 := builder.Table(passwordtoken.Table)
columns := ptq.ctx.Fields columns := _q.ctx.Fields
if len(columns) == 0 { if len(columns) == 0 {
columns = passwordtoken.Columns columns = passwordtoken.Columns
} }
selector := builder.Select(t1.Columns(columns...)...).From(t1) selector := builder.Select(t1.Columns(columns...)...).From(t1)
if ptq.sql != nil { if _q.sql != nil {
selector = ptq.sql selector = _q.sql
selector.Select(selector.Columns(columns...)...) selector.Select(selector.Columns(columns...)...)
} }
if ptq.ctx.Unique != nil && *ptq.ctx.Unique { if _q.ctx.Unique != nil && *_q.ctx.Unique {
selector.Distinct() selector.Distinct()
} }
for _, p := range ptq.predicates { for _, p := range _q.predicates {
p(selector) p(selector)
} }
for _, p := range ptq.order { for _, p := range _q.order {
p(selector) p(selector)
} }
if offset := ptq.ctx.Offset; offset != nil { if offset := _q.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start // limit is mandatory for offset clause. We start
// with default value, and override it below if needed. // with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32) selector.Offset(*offset).Limit(math.MaxInt32)
} }
if limit := ptq.ctx.Limit; limit != nil { if limit := _q.ctx.Limit; limit != nil {
selector.Limit(*limit) selector.Limit(*limit)
} }
return selector return selector
@ -522,41 +522,41 @@ type PasswordTokenGroupBy struct {
} }
// Aggregate adds the given aggregation functions to the group-by query. // Aggregate adds the given aggregation functions to the group-by query.
func (ptgb *PasswordTokenGroupBy) Aggregate(fns ...AggregateFunc) *PasswordTokenGroupBy { func (_g *PasswordTokenGroupBy) Aggregate(fns ...AggregateFunc) *PasswordTokenGroupBy {
ptgb.fns = append(ptgb.fns, fns...) _g.fns = append(_g.fns, fns...)
return ptgb return _g
} }
// Scan applies the selector query and scans the result into the given value. // Scan applies the selector query and scans the result into the given value.
func (ptgb *PasswordTokenGroupBy) Scan(ctx context.Context, v any) error { func (_g *PasswordTokenGroupBy) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, ptgb.build.ctx, ent.OpQueryGroupBy) ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
if err := ptgb.build.prepareQuery(ctx); err != nil { if err := _g.build.prepareQuery(ctx); err != nil {
return err 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() selector := root.sqlQuery(ctx).Select()
aggregation := make([]string, 0, len(ptgb.fns)) aggregation := make([]string, 0, len(_g.fns))
for _, fn := range ptgb.fns { for _, fn := range _g.fns {
aggregation = append(aggregation, fn(selector)) aggregation = append(aggregation, fn(selector))
} }
if len(selector.SelectedColumns()) == 0 { if len(selector.SelectedColumns()) == 0 {
columns := make([]string, 0, len(*ptgb.flds)+len(ptgb.fns)) columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
for _, f := range *ptgb.flds { for _, f := range *_g.flds {
columns = append(columns, selector.C(f)) columns = append(columns, selector.C(f))
} }
columns = append(columns, aggregation...) columns = append(columns, aggregation...)
selector.Select(columns...) selector.Select(columns...)
} }
selector.GroupBy(selector.Columns(*ptgb.flds...)...) selector.GroupBy(selector.Columns(*_g.flds...)...)
if err := selector.Err(); err != nil { if err := selector.Err(); err != nil {
return err return err
} }
rows := &sql.Rows{} rows := &sql.Rows{}
query, args := selector.Query() 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 return err
} }
defer rows.Close() defer rows.Close()
@ -570,27 +570,27 @@ type PasswordTokenSelect struct {
} }
// Aggregate adds the given aggregation functions to the selector query. // Aggregate adds the given aggregation functions to the selector query.
func (pts *PasswordTokenSelect) Aggregate(fns ...AggregateFunc) *PasswordTokenSelect { func (_s *PasswordTokenSelect) Aggregate(fns ...AggregateFunc) *PasswordTokenSelect {
pts.fns = append(pts.fns, fns...) _s.fns = append(_s.fns, fns...)
return pts return _s
} }
// Scan applies the selector query and scans the result into the given value. // Scan applies the selector query and scans the result into the given value.
func (pts *PasswordTokenSelect) Scan(ctx context.Context, v any) error { func (_s *PasswordTokenSelect) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, pts.ctx, ent.OpQuerySelect) ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
if err := pts.prepareQuery(ctx); err != nil { if err := _s.prepareQuery(ctx); err != nil {
return err 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) selector := root.sqlQuery(ctx)
aggregation := make([]string, 0, len(pts.fns)) aggregation := make([]string, 0, len(_s.fns))
for _, fn := range pts.fns { for _, fn := range _s.fns {
aggregation = append(aggregation, fn(selector)) aggregation = append(aggregation, fn(selector))
} }
switch n := len(*pts.selector.flds); { switch n := len(*_s.selector.flds); {
case n == 0 && len(aggregation) > 0: case n == 0 && len(aggregation) > 0:
selector.Select(aggregation...) selector.Select(aggregation...)
case n != 0 && len(aggregation) > 0: case n != 0 && len(aggregation) > 0:
@ -598,7 +598,7 @@ func (pts *PasswordTokenSelect) sqlScan(ctx context.Context, root *PasswordToken
} }
rows := &sql.Rows{} rows := &sql.Rows{}
query, args := selector.Query() 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 return err
} }
defer rows.Close() defer rows.Close()

220
ent/passwordtoken_update.go
View file

@ -24,77 +24,77 @@ type PasswordTokenUpdate struct {
} }
// Where appends a list predicates to the PasswordTokenUpdate builder. // Where appends a list predicates to the PasswordTokenUpdate builder.
func (ptu *PasswordTokenUpdate) Where(ps ...predicate.PasswordToken) *PasswordTokenUpdate { func (_u *PasswordTokenUpdate) Where(ps ...predicate.PasswordToken) *PasswordTokenUpdate {
ptu.mutation.Where(ps...) _u.mutation.Where(ps...)
return ptu return _u
} }
// SetToken sets the "token" field. // SetToken sets the "token" field.
func (ptu *PasswordTokenUpdate) SetToken(s string) *PasswordTokenUpdate { func (_u *PasswordTokenUpdate) SetToken(v string) *PasswordTokenUpdate {
ptu.mutation.SetToken(s) _u.mutation.SetToken(v)
return ptu return _u
} }
// SetNillableToken sets the "token" field if the given value is not nil. // SetNillableToken sets the "token" field if the given value is not nil.
func (ptu *PasswordTokenUpdate) SetNillableToken(s *string) *PasswordTokenUpdate { func (_u *PasswordTokenUpdate) SetNillableToken(v *string) *PasswordTokenUpdate {
if s != nil { if v != nil {
ptu.SetToken(*s) _u.SetToken(*v)
} }
return ptu return _u
} }
// SetUserID sets the "user_id" field. // SetUserID sets the "user_id" field.
func (ptu *PasswordTokenUpdate) SetUserID(i int) *PasswordTokenUpdate { func (_u *PasswordTokenUpdate) SetUserID(v int) *PasswordTokenUpdate {
ptu.mutation.SetUserID(i) _u.mutation.SetUserID(v)
return ptu return _u
} }
// SetNillableUserID sets the "user_id" field if the given value is not nil. // SetNillableUserID sets the "user_id" field if the given value is not nil.
func (ptu *PasswordTokenUpdate) SetNillableUserID(i *int) *PasswordTokenUpdate { func (_u *PasswordTokenUpdate) SetNillableUserID(v *int) *PasswordTokenUpdate {
if i != nil { if v != nil {
ptu.SetUserID(*i) _u.SetUserID(*v)
} }
return ptu return _u
} }
// SetCreatedAt sets the "created_at" field. // SetCreatedAt sets the "created_at" field.
func (ptu *PasswordTokenUpdate) SetCreatedAt(t time.Time) *PasswordTokenUpdate { func (_u *PasswordTokenUpdate) SetCreatedAt(v time.Time) *PasswordTokenUpdate {
ptu.mutation.SetCreatedAt(t) _u.mutation.SetCreatedAt(v)
return ptu return _u
} }
// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
func (ptu *PasswordTokenUpdate) SetNillableCreatedAt(t *time.Time) *PasswordTokenUpdate { func (_u *PasswordTokenUpdate) SetNillableCreatedAt(v *time.Time) *PasswordTokenUpdate {
if t != nil { if v != nil {
ptu.SetCreatedAt(*t) _u.SetCreatedAt(*v)
} }
return ptu return _u
} }
// SetUser sets the "user" edge to the User entity. // SetUser sets the "user" edge to the User entity.
func (ptu *PasswordTokenUpdate) SetUser(u *User) *PasswordTokenUpdate { func (_u *PasswordTokenUpdate) SetUser(v *User) *PasswordTokenUpdate {
return ptu.SetUserID(u.ID) return _u.SetUserID(v.ID)
} }
// Mutation returns the PasswordTokenMutation object of the builder. // Mutation returns the PasswordTokenMutation object of the builder.
func (ptu *PasswordTokenUpdate) Mutation() *PasswordTokenMutation { func (_u *PasswordTokenUpdate) Mutation() *PasswordTokenMutation {
return ptu.mutation return _u.mutation
} }
// ClearUser clears the "user" edge to the User entity. // ClearUser clears the "user" edge to the User entity.
func (ptu *PasswordTokenUpdate) ClearUser() *PasswordTokenUpdate { func (_u *PasswordTokenUpdate) ClearUser() *PasswordTokenUpdate {
ptu.mutation.ClearUser() _u.mutation.ClearUser()
return ptu return _u
} }
// Save executes the query and returns the number of nodes affected by the update operation. // Save executes the query and returns the number of nodes affected by the update operation.
func (ptu *PasswordTokenUpdate) Save(ctx context.Context) (int, error) { func (_u *PasswordTokenUpdate) Save(ctx context.Context) (int, error) {
return withHooks(ctx, ptu.sqlSave, ptu.mutation, ptu.hooks) return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
} }
// SaveX is like Save, but panics if an error occurs. // SaveX is like Save, but panics if an error occurs.
func (ptu *PasswordTokenUpdate) SaveX(ctx context.Context) int { func (_u *PasswordTokenUpdate) SaveX(ctx context.Context) int {
affected, err := ptu.Save(ctx) affected, err := _u.Save(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -102,50 +102,50 @@ func (ptu *PasswordTokenUpdate) SaveX(ctx context.Context) int {
} }
// Exec executes the query. // Exec executes the query.
func (ptu *PasswordTokenUpdate) Exec(ctx context.Context) error { func (_u *PasswordTokenUpdate) Exec(ctx context.Context) error {
_, err := ptu.Save(ctx) _, err := _u.Save(ctx)
return err return err
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (ptu *PasswordTokenUpdate) ExecX(ctx context.Context) { func (_u *PasswordTokenUpdate) ExecX(ctx context.Context) {
if err := ptu.Exec(ctx); err != nil { if err := _u.Exec(ctx); err != nil {
panic(err) panic(err)
} }
} }
// check runs all checks and user-defined validators on the builder. // check runs all checks and user-defined validators on the builder.
func (ptu *PasswordTokenUpdate) check() error { func (_u *PasswordTokenUpdate) check() error {
if v, ok := ptu.mutation.Token(); ok { if v, ok := _u.mutation.Token(); ok {
if err := passwordtoken.TokenValidator(v); err != nil { if err := passwordtoken.TokenValidator(v); err != nil {
return &ValidationError{Name: "token", err: fmt.Errorf(`ent: validator failed for field "PasswordToken.token": %w`, err)} 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 errors.New(`ent: clearing a required unique edge "PasswordToken.user"`)
} }
return nil return nil
} }
func (ptu *PasswordTokenUpdate) sqlSave(ctx context.Context) (n int, err error) { func (_u *PasswordTokenUpdate) sqlSave(ctx context.Context) (_node int, err error) {
if err := ptu.check(); err != nil { if err := _u.check(); err != nil {
return n, err return _node, err
} }
_spec := sqlgraph.NewUpdateSpec(passwordtoken.Table, passwordtoken.Columns, sqlgraph.NewFieldSpec(passwordtoken.FieldID, field.TypeInt)) _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) { _spec.Predicate = func(selector *sql.Selector) {
for i := range ps { for i := range ps {
ps[i](selector) ps[i](selector)
} }
} }
} }
if value, ok := ptu.mutation.Token(); ok { if value, ok := _u.mutation.Token(); ok {
_spec.SetField(passwordtoken.FieldToken, field.TypeString, value) _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) _spec.SetField(passwordtoken.FieldCreatedAt, field.TypeTime, value)
} }
if ptu.mutation.UserCleared() { if _u.mutation.UserCleared() {
edge := &sqlgraph.EdgeSpec{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O, Rel: sqlgraph.M2O,
Inverse: false, 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) _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{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O, Rel: sqlgraph.M2O,
Inverse: false, 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) _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 { if _, ok := err.(*sqlgraph.NotFoundError); ok {
err = &NotFoundError{passwordtoken.Label} err = &NotFoundError{passwordtoken.Label}
} else if sqlgraph.IsConstraintError(err) { } else if sqlgraph.IsConstraintError(err) {
@ -182,8 +182,8 @@ func (ptu *PasswordTokenUpdate) sqlSave(ctx context.Context) (n int, err error)
} }
return 0, err return 0, err
} }
ptu.mutation.done = true _u.mutation.done = true
return n, nil return _node, nil
} }
// PasswordTokenUpdateOne is the builder for updating a single PasswordToken entity. // PasswordTokenUpdateOne is the builder for updating a single PasswordToken entity.
@ -195,84 +195,84 @@ type PasswordTokenUpdateOne struct {
} }
// SetToken sets the "token" field. // SetToken sets the "token" field.
func (ptuo *PasswordTokenUpdateOne) SetToken(s string) *PasswordTokenUpdateOne { func (_u *PasswordTokenUpdateOne) SetToken(v string) *PasswordTokenUpdateOne {
ptuo.mutation.SetToken(s) _u.mutation.SetToken(v)
return ptuo return _u
} }
// SetNillableToken sets the "token" field if the given value is not nil. // SetNillableToken sets the "token" field if the given value is not nil.
func (ptuo *PasswordTokenUpdateOne) SetNillableToken(s *string) *PasswordTokenUpdateOne { func (_u *PasswordTokenUpdateOne) SetNillableToken(v *string) *PasswordTokenUpdateOne {
if s != nil { if v != nil {
ptuo.SetToken(*s) _u.SetToken(*v)
} }
return ptuo return _u
} }
// SetUserID sets the "user_id" field. // SetUserID sets the "user_id" field.
func (ptuo *PasswordTokenUpdateOne) SetUserID(i int) *PasswordTokenUpdateOne { func (_u *PasswordTokenUpdateOne) SetUserID(v int) *PasswordTokenUpdateOne {
ptuo.mutation.SetUserID(i) _u.mutation.SetUserID(v)
return ptuo return _u
} }
// SetNillableUserID sets the "user_id" field if the given value is not nil. // SetNillableUserID sets the "user_id" field if the given value is not nil.
func (ptuo *PasswordTokenUpdateOne) SetNillableUserID(i *int) *PasswordTokenUpdateOne { func (_u *PasswordTokenUpdateOne) SetNillableUserID(v *int) *PasswordTokenUpdateOne {
if i != nil { if v != nil {
ptuo.SetUserID(*i) _u.SetUserID(*v)
} }
return ptuo return _u
} }
// SetCreatedAt sets the "created_at" field. // SetCreatedAt sets the "created_at" field.
func (ptuo *PasswordTokenUpdateOne) SetCreatedAt(t time.Time) *PasswordTokenUpdateOne { func (_u *PasswordTokenUpdateOne) SetCreatedAt(v time.Time) *PasswordTokenUpdateOne {
ptuo.mutation.SetCreatedAt(t) _u.mutation.SetCreatedAt(v)
return ptuo return _u
} }
// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
func (ptuo *PasswordTokenUpdateOne) SetNillableCreatedAt(t *time.Time) *PasswordTokenUpdateOne { func (_u *PasswordTokenUpdateOne) SetNillableCreatedAt(v *time.Time) *PasswordTokenUpdateOne {
if t != nil { if v != nil {
ptuo.SetCreatedAt(*t) _u.SetCreatedAt(*v)
} }
return ptuo return _u
} }
// SetUser sets the "user" edge to the User entity. // SetUser sets the "user" edge to the User entity.
func (ptuo *PasswordTokenUpdateOne) SetUser(u *User) *PasswordTokenUpdateOne { func (_u *PasswordTokenUpdateOne) SetUser(v *User) *PasswordTokenUpdateOne {
return ptuo.SetUserID(u.ID) return _u.SetUserID(v.ID)
} }
// Mutation returns the PasswordTokenMutation object of the builder. // Mutation returns the PasswordTokenMutation object of the builder.
func (ptuo *PasswordTokenUpdateOne) Mutation() *PasswordTokenMutation { func (_u *PasswordTokenUpdateOne) Mutation() *PasswordTokenMutation {
return ptuo.mutation return _u.mutation
} }
// ClearUser clears the "user" edge to the User entity. // ClearUser clears the "user" edge to the User entity.
func (ptuo *PasswordTokenUpdateOne) ClearUser() *PasswordTokenUpdateOne { func (_u *PasswordTokenUpdateOne) ClearUser() *PasswordTokenUpdateOne {
ptuo.mutation.ClearUser() _u.mutation.ClearUser()
return ptuo return _u
} }
// Where appends a list predicates to the PasswordTokenUpdate builder. // Where appends a list predicates to the PasswordTokenUpdate builder.
func (ptuo *PasswordTokenUpdateOne) Where(ps ...predicate.PasswordToken) *PasswordTokenUpdateOne { func (_u *PasswordTokenUpdateOne) Where(ps ...predicate.PasswordToken) *PasswordTokenUpdateOne {
ptuo.mutation.Where(ps...) _u.mutation.Where(ps...)
return ptuo return _u
} }
// Select allows selecting one or more fields (columns) of the returned entity. // Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema. // The default is selecting all fields defined in the entity schema.
func (ptuo *PasswordTokenUpdateOne) Select(field string, fields ...string) *PasswordTokenUpdateOne { func (_u *PasswordTokenUpdateOne) Select(field string, fields ...string) *PasswordTokenUpdateOne {
ptuo.fields = append([]string{field}, fields...) _u.fields = append([]string{field}, fields...)
return ptuo return _u
} }
// Save executes the query and returns the updated PasswordToken entity. // Save executes the query and returns the updated PasswordToken entity.
func (ptuo *PasswordTokenUpdateOne) Save(ctx context.Context) (*PasswordToken, error) { func (_u *PasswordTokenUpdateOne) Save(ctx context.Context) (*PasswordToken, error) {
return withHooks(ctx, ptuo.sqlSave, ptuo.mutation, ptuo.hooks) return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
} }
// SaveX is like Save, but panics if an error occurs. // SaveX is like Save, but panics if an error occurs.
func (ptuo *PasswordTokenUpdateOne) SaveX(ctx context.Context) *PasswordToken { func (_u *PasswordTokenUpdateOne) SaveX(ctx context.Context) *PasswordToken {
node, err := ptuo.Save(ctx) node, err := _u.Save(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -280,42 +280,42 @@ func (ptuo *PasswordTokenUpdateOne) SaveX(ctx context.Context) *PasswordToken {
} }
// Exec executes the query on the entity. // Exec executes the query on the entity.
func (ptuo *PasswordTokenUpdateOne) Exec(ctx context.Context) error { func (_u *PasswordTokenUpdateOne) Exec(ctx context.Context) error {
_, err := ptuo.Save(ctx) _, err := _u.Save(ctx)
return err return err
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (ptuo *PasswordTokenUpdateOne) ExecX(ctx context.Context) { func (_u *PasswordTokenUpdateOne) ExecX(ctx context.Context) {
if err := ptuo.Exec(ctx); err != nil { if err := _u.Exec(ctx); err != nil {
panic(err) panic(err)
} }
} }
// check runs all checks and user-defined validators on the builder. // check runs all checks and user-defined validators on the builder.
func (ptuo *PasswordTokenUpdateOne) check() error { func (_u *PasswordTokenUpdateOne) check() error {
if v, ok := ptuo.mutation.Token(); ok { if v, ok := _u.mutation.Token(); ok {
if err := passwordtoken.TokenValidator(v); err != nil { if err := passwordtoken.TokenValidator(v); err != nil {
return &ValidationError{Name: "token", err: fmt.Errorf(`ent: validator failed for field "PasswordToken.token": %w`, err)} 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 errors.New(`ent: clearing a required unique edge "PasswordToken.user"`)
} }
return nil return nil
} }
func (ptuo *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *PasswordToken, err error) { func (_u *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *PasswordToken, err error) {
if err := ptuo.check(); err != nil { if err := _u.check(); err != nil {
return _node, err return _node, err
} }
_spec := sqlgraph.NewUpdateSpec(passwordtoken.Table, passwordtoken.Columns, sqlgraph.NewFieldSpec(passwordtoken.FieldID, field.TypeInt)) _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 { if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "PasswordToken.id" for update`)} return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "PasswordToken.id" for update`)}
} }
_spec.Node.ID.Value = id _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 = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, passwordtoken.FieldID) _spec.Node.Columns = append(_spec.Node.Columns, passwordtoken.FieldID)
for _, f := range fields { 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) { _spec.Predicate = func(selector *sql.Selector) {
for i := range ps { for i := range ps {
ps[i](selector) ps[i](selector)
} }
} }
} }
if value, ok := ptuo.mutation.Token(); ok { if value, ok := _u.mutation.Token(); ok {
_spec.SetField(passwordtoken.FieldToken, field.TypeString, value) _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) _spec.SetField(passwordtoken.FieldCreatedAt, field.TypeTime, value)
} }
if ptuo.mutation.UserCleared() { if _u.mutation.UserCleared() {
edge := &sqlgraph.EdgeSpec{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O, Rel: sqlgraph.M2O,
Inverse: false, Inverse: false,
@ -353,7 +353,7 @@ func (ptuo *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *Passwor
} }
_spec.Edges.Clear = append(_spec.Edges.Clear, edge) _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{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O, Rel: sqlgraph.M2O,
Inverse: false, Inverse: false,
@ -369,10 +369,10 @@ func (ptuo *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *Passwor
} }
_spec.Edges.Add = append(_spec.Edges.Add, edge) _spec.Edges.Add = append(_spec.Edges.Add, edge)
} }
_node = &PasswordToken{config: ptuo.config} _node = &PasswordToken{config: _u.config}
_spec.Assign = _node.assignValues _spec.Assign = _node.assignValues
_spec.ScanValues = _node.scanValues _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 { if _, ok := err.(*sqlgraph.NotFoundError); ok {
err = &NotFoundError{passwordtoken.Label} err = &NotFoundError{passwordtoken.Label}
} else if sqlgraph.IsConstraintError(err) { } else if sqlgraph.IsConstraintError(err) {
@ -380,6 +380,6 @@ func (ptuo *PasswordTokenUpdateOne) sqlSave(ctx context.Context) (_node *Passwor
} }
return nil, err return nil, err
} }
ptuo.mutation.done = true _u.mutation.done = true
return _node, nil return _node, nil
} }

4
ent/runtime/runtime.go
View file

@ -71,6 +71,6 @@ func init() {
} }
const ( const (
Version = "v0.14.4" // Version of ent codegen. Version = "v0.14.5" // Version of ent codegen.
Sum = "h1:/DhDraSLXIkBhyiVoJeSshr4ZYi7femzhj6/TckzZuI=" // Sum of ent codegen. Sum = "h1:Rj2WOYJtCkWyFo6a+5wB3EfBRP0rnx1fMk6gGA0UUe4=" // Sum of ent codegen.
) )

52
ent/user.go
View file

@ -75,7 +75,7 @@ func (*User) scanValues(columns []string) ([]any, error) {
// assignValues assigns the values that were returned from sql.Rows (after scanning) // assignValues assigns the values that were returned from sql.Rows (after scanning)
// to the User fields. // 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 { if m, n := len(values), len(columns); m < n {
return fmt.Errorf("mismatch number of scan values: %d != %d", 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 { if !ok {
return fmt.Errorf("unexpected type %T for field id", value) return fmt.Errorf("unexpected type %T for field id", value)
} }
u.ID = int(value.Int64) _m.ID = int(value.Int64)
case user.FieldName: case user.FieldName:
if value, ok := values[i].(*sql.NullString); !ok { if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field name", values[i]) return fmt.Errorf("unexpected type %T for field name", values[i])
} else if value.Valid { } else if value.Valid {
u.Name = value.String _m.Name = value.String
} }
case user.FieldEmail: case user.FieldEmail:
if value, ok := values[i].(*sql.NullString); !ok { if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field email", values[i]) return fmt.Errorf("unexpected type %T for field email", values[i])
} else if value.Valid { } else if value.Valid {
u.Email = value.String _m.Email = value.String
} }
case user.FieldPassword: case user.FieldPassword:
if value, ok := values[i].(*sql.NullString); !ok { if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field password", values[i]) return fmt.Errorf("unexpected type %T for field password", values[i])
} else if value.Valid { } else if value.Valid {
u.Password = value.String _m.Password = value.String
} }
case user.FieldVerified: case user.FieldVerified:
if value, ok := values[i].(*sql.NullBool); !ok { if value, ok := values[i].(*sql.NullBool); !ok {
return fmt.Errorf("unexpected type %T for field verified", values[i]) return fmt.Errorf("unexpected type %T for field verified", values[i])
} else if value.Valid { } else if value.Valid {
u.Verified = value.Bool _m.Verified = value.Bool
} }
case user.FieldAdmin: case user.FieldAdmin:
if value, ok := values[i].(*sql.NullBool); !ok { if value, ok := values[i].(*sql.NullBool); !ok {
return fmt.Errorf("unexpected type %T for field admin", values[i]) return fmt.Errorf("unexpected type %T for field admin", values[i])
} else if value.Valid { } else if value.Valid {
u.Admin = value.Bool _m.Admin = value.Bool
} }
case user.FieldCreatedAt: case user.FieldCreatedAt:
if value, ok := values[i].(*sql.NullTime); !ok { if value, ok := values[i].(*sql.NullTime); !ok {
return fmt.Errorf("unexpected type %T for field created_at", values[i]) return fmt.Errorf("unexpected type %T for field created_at", values[i])
} else if value.Valid { } else if value.Valid {
u.CreatedAt = value.Time _m.CreatedAt = value.Time
} }
default: default:
u.selectValues.Set(columns[i], values[i]) _m.selectValues.Set(columns[i], values[i])
} }
} }
return nil 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. // Value returns the ent.Value that was dynamically selected and assigned to the User.
// This includes values selected through modifiers, order, etc. // This includes values selected through modifiers, order, etc.
func (u *User) Value(name string) (ent.Value, error) { func (_m *User) Value(name string) (ent.Value, error) {
return u.selectValues.Get(name) return _m.selectValues.Get(name)
} }
// QueryOwner queries the "owner" edge of the User entity. // QueryOwner queries the "owner" edge of the User entity.
func (u *User) QueryOwner() *PasswordTokenQuery { func (_m *User) QueryOwner() *PasswordTokenQuery {
return NewUserClient(u.config).QueryOwner(u) return NewUserClient(_m.config).QueryOwner(_m)
} }
// Update returns a builder for updating this User. // Update returns a builder for updating this User.
// Note that you need to call User.Unwrap() before calling this method if 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. // was returned from a transaction, and the transaction was committed or rolled back.
func (u *User) Update() *UserUpdateOne { func (_m *User) Update() *UserUpdateOne {
return NewUserClient(u.config).UpdateOne(u) return NewUserClient(_m.config).UpdateOne(_m)
} }
// Unwrap unwraps the User entity that was returned from a transaction after it was closed, // 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. // so that all future queries will be executed through the driver which created the transaction.
func (u *User) Unwrap() *User { func (_m *User) Unwrap() *User {
_tx, ok := u.config.driver.(*txDriver) _tx, ok := _m.config.driver.(*txDriver)
if !ok { if !ok {
panic("ent: User is not a transactional entity") panic("ent: User is not a transactional entity")
} }
u.config.driver = _tx.drv _m.config.driver = _tx.drv
return u return _m
} }
// String implements the fmt.Stringer. // String implements the fmt.Stringer.
func (u *User) String() string { func (_m *User) String() string {
var builder strings.Builder var builder strings.Builder
builder.WriteString("User(") builder.WriteString("User(")
builder.WriteString(fmt.Sprintf("id=%v, ", u.ID)) builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
builder.WriteString("name=") builder.WriteString("name=")
builder.WriteString(u.Name) builder.WriteString(_m.Name)
builder.WriteString(", ") builder.WriteString(", ")
builder.WriteString("email=") builder.WriteString("email=")
builder.WriteString(u.Email) builder.WriteString(_m.Email)
builder.WriteString(", ") builder.WriteString(", ")
builder.WriteString("password=<sensitive>") builder.WriteString("password=<sensitive>")
builder.WriteString(", ") builder.WriteString(", ")
builder.WriteString("verified=") builder.WriteString("verified=")
builder.WriteString(fmt.Sprintf("%v", u.Verified)) builder.WriteString(fmt.Sprintf("%v", _m.Verified))
builder.WriteString(", ") builder.WriteString(", ")
builder.WriteString("admin=") builder.WriteString("admin=")
builder.WriteString(fmt.Sprintf("%v", u.Admin)) builder.WriteString(fmt.Sprintf("%v", _m.Admin))
builder.WriteString(", ") builder.WriteString(", ")
builder.WriteString("created_at=") builder.WriteString("created_at=")
builder.WriteString(u.CreatedAt.Format(time.ANSIC)) builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
builder.WriteByte(')') builder.WriteByte(')')
return builder.String() return builder.String()
} }

196
ent/user_create.go
View file

@ -22,96 +22,96 @@ type UserCreate struct {
} }
// SetName sets the "name" field. // SetName sets the "name" field.
func (uc *UserCreate) SetName(s string) *UserCreate { func (_c *UserCreate) SetName(v string) *UserCreate {
uc.mutation.SetName(s) _c.mutation.SetName(v)
return uc return _c
} }
// SetEmail sets the "email" field. // SetEmail sets the "email" field.
func (uc *UserCreate) SetEmail(s string) *UserCreate { func (_c *UserCreate) SetEmail(v string) *UserCreate {
uc.mutation.SetEmail(s) _c.mutation.SetEmail(v)
return uc return _c
} }
// SetPassword sets the "password" field. // SetPassword sets the "password" field.
func (uc *UserCreate) SetPassword(s string) *UserCreate { func (_c *UserCreate) SetPassword(v string) *UserCreate {
uc.mutation.SetPassword(s) _c.mutation.SetPassword(v)
return uc return _c
} }
// SetVerified sets the "verified" field. // SetVerified sets the "verified" field.
func (uc *UserCreate) SetVerified(b bool) *UserCreate { func (_c *UserCreate) SetVerified(v bool) *UserCreate {
uc.mutation.SetVerified(b) _c.mutation.SetVerified(v)
return uc return _c
} }
// SetNillableVerified sets the "verified" field if the given value is not nil. // SetNillableVerified sets the "verified" field if the given value is not nil.
func (uc *UserCreate) SetNillableVerified(b *bool) *UserCreate { func (_c *UserCreate) SetNillableVerified(v *bool) *UserCreate {
if b != nil { if v != nil {
uc.SetVerified(*b) _c.SetVerified(*v)
} }
return uc return _c
} }
// SetAdmin sets the "admin" field. // SetAdmin sets the "admin" field.
func (uc *UserCreate) SetAdmin(b bool) *UserCreate { func (_c *UserCreate) SetAdmin(v bool) *UserCreate {
uc.mutation.SetAdmin(b) _c.mutation.SetAdmin(v)
return uc return _c
} }
// SetNillableAdmin sets the "admin" field if the given value is not nil. // SetNillableAdmin sets the "admin" field if the given value is not nil.
func (uc *UserCreate) SetNillableAdmin(b *bool) *UserCreate { func (_c *UserCreate) SetNillableAdmin(v *bool) *UserCreate {
if b != nil { if v != nil {
uc.SetAdmin(*b) _c.SetAdmin(*v)
} }
return uc return _c
} }
// SetCreatedAt sets the "created_at" field. // SetCreatedAt sets the "created_at" field.
func (uc *UserCreate) SetCreatedAt(t time.Time) *UserCreate { func (_c *UserCreate) SetCreatedAt(v time.Time) *UserCreate {
uc.mutation.SetCreatedAt(t) _c.mutation.SetCreatedAt(v)
return uc return _c
} }
// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. // SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
func (uc *UserCreate) SetNillableCreatedAt(t *time.Time) *UserCreate { func (_c *UserCreate) SetNillableCreatedAt(v *time.Time) *UserCreate {
if t != nil { if v != nil {
uc.SetCreatedAt(*t) _c.SetCreatedAt(*v)
} }
return uc return _c
} }
// AddOwnerIDs adds the "owner" edge to the PasswordToken entity by IDs. // AddOwnerIDs adds the "owner" edge to the PasswordToken entity by IDs.
func (uc *UserCreate) AddOwnerIDs(ids ...int) *UserCreate { func (_c *UserCreate) AddOwnerIDs(ids ...int) *UserCreate {
uc.mutation.AddOwnerIDs(ids...) _c.mutation.AddOwnerIDs(ids...)
return uc return _c
} }
// AddOwner adds the "owner" edges to the PasswordToken entity. // AddOwner adds the "owner" edges to the PasswordToken entity.
func (uc *UserCreate) AddOwner(p ...*PasswordToken) *UserCreate { func (_c *UserCreate) AddOwner(v ...*PasswordToken) *UserCreate {
ids := make([]int, len(p)) ids := make([]int, len(v))
for i := range p { for i := range v {
ids[i] = p[i].ID ids[i] = v[i].ID
} }
return uc.AddOwnerIDs(ids...) return _c.AddOwnerIDs(ids...)
} }
// Mutation returns the UserMutation object of the builder. // Mutation returns the UserMutation object of the builder.
func (uc *UserCreate) Mutation() *UserMutation { func (_c *UserCreate) Mutation() *UserMutation {
return uc.mutation return _c.mutation
} }
// Save creates the User in the database. // Save creates the User in the database.
func (uc *UserCreate) Save(ctx context.Context) (*User, error) { func (_c *UserCreate) Save(ctx context.Context) (*User, error) {
if err := uc.defaults(); err != nil { if err := _c.defaults(); err != nil {
return nil, err 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. // SaveX calls Save and panics if Save returns an error.
func (uc *UserCreate) SaveX(ctx context.Context) *User { func (_c *UserCreate) SaveX(ctx context.Context) *User {
v, err := uc.Save(ctx) v, err := _c.Save(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -119,82 +119,82 @@ func (uc *UserCreate) SaveX(ctx context.Context) *User {
} }
// Exec executes the query. // Exec executes the query.
func (uc *UserCreate) Exec(ctx context.Context) error { func (_c *UserCreate) Exec(ctx context.Context) error {
_, err := uc.Save(ctx) _, err := _c.Save(ctx)
return err return err
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (uc *UserCreate) ExecX(ctx context.Context) { func (_c *UserCreate) ExecX(ctx context.Context) {
if err := uc.Exec(ctx); err != nil { if err := _c.Exec(ctx); err != nil {
panic(err) panic(err)
} }
} }
// defaults sets the default values of the builder before save. // defaults sets the default values of the builder before save.
func (uc *UserCreate) defaults() error { func (_c *UserCreate) defaults() error {
if _, ok := uc.mutation.Verified(); !ok { if _, ok := _c.mutation.Verified(); !ok {
v := user.DefaultVerified 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 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 { if user.DefaultCreatedAt == nil {
return fmt.Errorf("ent: uninitialized user.DefaultCreatedAt (forgotten import ent/runtime?)") return fmt.Errorf("ent: uninitialized user.DefaultCreatedAt (forgotten import ent/runtime?)")
} }
v := user.DefaultCreatedAt() v := user.DefaultCreatedAt()
uc.mutation.SetCreatedAt(v) _c.mutation.SetCreatedAt(v)
} }
return nil return nil
} }
// check runs all checks and user-defined validators on the builder. // check runs all checks and user-defined validators on the builder.
func (uc *UserCreate) check() error { func (_c *UserCreate) check() error {
if _, ok := uc.mutation.Name(); !ok { if _, ok := _c.mutation.Name(); !ok {
return &ValidationError{Name: "name", err: errors.New(`ent: missing required field "User.name"`)} 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 { if err := user.NameValidator(v); err != nil {
return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "User.name": %w`, err)} 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"`)} 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 { if err := user.EmailValidator(v); err != nil {
return &ValidationError{Name: "email", err: fmt.Errorf(`ent: validator failed for field "User.email": %w`, err)} 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"`)} 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 { if err := user.PasswordValidator(v); err != nil {
return &ValidationError{Name: "password", err: fmt.Errorf(`ent: validator failed for field "User.password": %w`, err)} 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"`)} 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"`)} 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 &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "User.created_at"`)}
} }
return nil return nil
} }
func (uc *UserCreate) sqlSave(ctx context.Context) (*User, error) { func (_c *UserCreate) sqlSave(ctx context.Context) (*User, error) {
if err := uc.check(); err != nil { if err := _c.check(); err != nil {
return nil, err return nil, err
} }
_node, _spec := uc.createSpec() _node, _spec := _c.createSpec()
if err := sqlgraph.CreateNode(ctx, uc.driver, _spec); err != nil { if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil {
if sqlgraph.IsConstraintError(err) { if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: 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) id := _spec.ID.Value.(int64)
_node.ID = int(id) _node.ID = int(id)
uc.mutation.id = &_node.ID _c.mutation.id = &_node.ID
uc.mutation.done = true _c.mutation.done = true
return _node, nil return _node, nil
} }
func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { func (_c *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
var ( var (
_node = &User{config: uc.config} _node = &User{config: _c.config}
_spec = sqlgraph.NewCreateSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) _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) _spec.SetField(user.FieldName, field.TypeString, value)
_node.Name = 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) _spec.SetField(user.FieldEmail, field.TypeString, value)
_node.Email = 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) _spec.SetField(user.FieldPassword, field.TypeString, value)
_node.Password = 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) _spec.SetField(user.FieldVerified, field.TypeBool, value)
_node.Verified = 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) _spec.SetField(user.FieldAdmin, field.TypeBool, value)
_node.Admin = 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) _spec.SetField(user.FieldCreatedAt, field.TypeTime, value)
_node.CreatedAt = value _node.CreatedAt = value
} }
if nodes := uc.mutation.OwnerIDs(); len(nodes) > 0 { if nodes := _c.mutation.OwnerIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M, Rel: sqlgraph.O2M,
Inverse: true, Inverse: true,
@ -263,16 +263,16 @@ type UserCreateBulk struct {
} }
// Save creates the User entities in the database. // Save creates the User entities in the database.
func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { func (_c *UserCreateBulk) Save(ctx context.Context) ([]*User, error) {
if ucb.err != nil { if _c.err != nil {
return nil, ucb.err return nil, _c.err
} }
specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
nodes := make([]*User, len(ucb.builders)) nodes := make([]*User, len(_c.builders))
mutators := make([]Mutator, len(ucb.builders)) mutators := make([]Mutator, len(_c.builders))
for i := range ucb.builders { for i := range _c.builders {
func(i int, root context.Context) { func(i int, root context.Context) {
builder := ucb.builders[i] builder := _c.builders[i]
builder.defaults() builder.defaults()
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
mutation, ok := m.(*UserMutation) mutation, ok := m.(*UserMutation)
@ -286,11 +286,11 @@ func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) {
var err error var err error
nodes[i], specs[i] = builder.createSpec() nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 { 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 { } else {
spec := &sqlgraph.BatchCreateSpec{Nodes: specs} spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
// Invoke the actual operation on the latest mutation in the chain. // 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) { if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err} err = &ConstraintError{msg: err.Error(), wrap: err}
} }
@ -314,7 +314,7 @@ func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) {
}(i, ctx) }(i, ctx)
} }
if len(mutators) > 0 { 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 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. // SaveX is like Save, but panics if an error occurs.
func (ucb *UserCreateBulk) SaveX(ctx context.Context) []*User { func (_c *UserCreateBulk) SaveX(ctx context.Context) []*User {
v, err := ucb.Save(ctx) v, err := _c.Save(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -331,14 +331,14 @@ func (ucb *UserCreateBulk) SaveX(ctx context.Context) []*User {
} }
// Exec executes the query. // Exec executes the query.
func (ucb *UserCreateBulk) Exec(ctx context.Context) error { func (_c *UserCreateBulk) Exec(ctx context.Context) error {
_, err := ucb.Save(ctx) _, err := _c.Save(ctx)
return err return err
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (ucb *UserCreateBulk) ExecX(ctx context.Context) { func (_c *UserCreateBulk) ExecX(ctx context.Context) {
if err := ucb.Exec(ctx); err != nil { if err := _c.Exec(ctx); err != nil {
panic(err) panic(err)
} }
} }

38
ent/user_delete.go
View file

@ -20,56 +20,56 @@ type UserDelete struct {
} }
// Where appends a list predicates to the UserDelete builder. // Where appends a list predicates to the UserDelete builder.
func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { func (_d *UserDelete) Where(ps ...predicate.User) *UserDelete {
ud.mutation.Where(ps...) _d.mutation.Where(ps...)
return ud return _d
} }
// Exec executes the deletion query and returns how many vertices were deleted. // Exec executes the deletion query and returns how many vertices were deleted.
func (ud *UserDelete) Exec(ctx context.Context) (int, error) { func (_d *UserDelete) Exec(ctx context.Context) (int, error) {
return withHooks(ctx, ud.sqlExec, ud.mutation, ud.hooks) return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (ud *UserDelete) ExecX(ctx context.Context) int { func (_d *UserDelete) ExecX(ctx context.Context) int {
n, err := ud.Exec(ctx) n, err := _d.Exec(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
return n 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)) _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) { _spec.Predicate = func(selector *sql.Selector) {
for i := range ps { for i := range ps {
ps[i](selector) 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) { if err != nil && sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err} err = &ConstraintError{msg: err.Error(), wrap: err}
} }
ud.mutation.done = true _d.mutation.done = true
return affected, err return affected, err
} }
// UserDeleteOne is the builder for deleting a single User entity. // UserDeleteOne is the builder for deleting a single User entity.
type UserDeleteOne struct { type UserDeleteOne struct {
ud *UserDelete _d *UserDelete
} }
// Where appends a list predicates to the UserDelete builder. // Where appends a list predicates to the UserDelete builder.
func (udo *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne { func (_d *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne {
udo.ud.mutation.Where(ps...) _d._d.mutation.Where(ps...)
return udo return _d
} }
// Exec executes the deletion query. // Exec executes the deletion query.
func (udo *UserDeleteOne) Exec(ctx context.Context) error { func (_d *UserDeleteOne) Exec(ctx context.Context) error {
n, err := udo.ud.Exec(ctx) n, err := _d._d.Exec(ctx)
switch { switch {
case err != nil: case err != nil:
return err return err
@ -81,8 +81,8 @@ func (udo *UserDeleteOne) Exec(ctx context.Context) error {
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (udo *UserDeleteOne) ExecX(ctx context.Context) { func (_d *UserDeleteOne) ExecX(ctx context.Context) {
if err := udo.Exec(ctx); err != nil { if err := _d.Exec(ctx); err != nil {
panic(err) panic(err)
} }
} }

300
ent/user_query.go
View file

@ -31,44 +31,44 @@ type UserQuery struct {
} }
// Where adds a new predicate for the UserQuery builder. // Where adds a new predicate for the UserQuery builder.
func (uq *UserQuery) Where(ps ...predicate.User) *UserQuery { func (_q *UserQuery) Where(ps ...predicate.User) *UserQuery {
uq.predicates = append(uq.predicates, ps...) _q.predicates = append(_q.predicates, ps...)
return uq return _q
} }
// Limit the number of records to be returned by this query. // Limit the number of records to be returned by this query.
func (uq *UserQuery) Limit(limit int) *UserQuery { func (_q *UserQuery) Limit(limit int) *UserQuery {
uq.ctx.Limit = &limit _q.ctx.Limit = &limit
return uq return _q
} }
// Offset to start from. // Offset to start from.
func (uq *UserQuery) Offset(offset int) *UserQuery { func (_q *UserQuery) Offset(offset int) *UserQuery {
uq.ctx.Offset = &offset _q.ctx.Offset = &offset
return uq return _q
} }
// Unique configures the query builder to filter duplicate records on query. // 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. // By default, unique is set to true, and can be disabled using this method.
func (uq *UserQuery) Unique(unique bool) *UserQuery { func (_q *UserQuery) Unique(unique bool) *UserQuery {
uq.ctx.Unique = &unique _q.ctx.Unique = &unique
return uq return _q
} }
// Order specifies how the records should be ordered. // Order specifies how the records should be ordered.
func (uq *UserQuery) Order(o ...user.OrderOption) *UserQuery { func (_q *UserQuery) Order(o ...user.OrderOption) *UserQuery {
uq.order = append(uq.order, o...) _q.order = append(_q.order, o...)
return uq return _q
} }
// QueryOwner chains the current query on the "owner" edge. // QueryOwner chains the current query on the "owner" edge.
func (uq *UserQuery) QueryOwner() *PasswordTokenQuery { func (_q *UserQuery) QueryOwner() *PasswordTokenQuery {
query := (&PasswordTokenClient{config: uq.config}).Query() query := (&PasswordTokenClient{config: _q.config}).Query()
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { 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 return nil, err
} }
selector := uq.sqlQuery(ctx) selector := _q.sqlQuery(ctx)
if err := selector.Err(); err != nil { if err := selector.Err(); err != nil {
return nil, err return nil, err
} }
@ -77,7 +77,7 @@ func (uq *UserQuery) QueryOwner() *PasswordTokenQuery {
sqlgraph.To(passwordtoken.Table, passwordtoken.FieldID), sqlgraph.To(passwordtoken.Table, passwordtoken.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, user.OwnerTable, user.OwnerColumn), 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 fromU, nil
} }
return query return query
@ -85,8 +85,8 @@ func (uq *UserQuery) QueryOwner() *PasswordTokenQuery {
// First returns the first User entity from the query. // First returns the first User entity from the query.
// Returns a *NotFoundError when no User was found. // Returns a *NotFoundError when no User was found.
func (uq *UserQuery) First(ctx context.Context) (*User, error) { func (_q *UserQuery) First(ctx context.Context) (*User, error) {
nodes, err := uq.Limit(1).All(setContextOp(ctx, uq.ctx, ent.OpQueryFirst)) nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
if err != nil { if err != nil {
return nil, err 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. // FirstX is like First, but panics if an error occurs.
func (uq *UserQuery) FirstX(ctx context.Context) *User { func (_q *UserQuery) FirstX(ctx context.Context) *User {
node, err := uq.First(ctx) node, err := _q.First(ctx)
if err != nil && !IsNotFound(err) { if err != nil && !IsNotFound(err) {
panic(err) panic(err)
} }
@ -107,9 +107,9 @@ func (uq *UserQuery) FirstX(ctx context.Context) *User {
// FirstID returns the first User ID from the query. // FirstID returns the first User ID from the query.
// Returns a *NotFoundError when no User ID was found. // 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 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 return
} }
if len(ids) == 0 { 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. // FirstIDX is like FirstID, but panics if an error occurs.
func (uq *UserQuery) FirstIDX(ctx context.Context) int { func (_q *UserQuery) FirstIDX(ctx context.Context) int {
id, err := uq.FirstID(ctx) id, err := _q.FirstID(ctx)
if err != nil && !IsNotFound(err) { if err != nil && !IsNotFound(err) {
panic(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. // 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 *NotSingularError when more than one User entity is found.
// Returns a *NotFoundError when no User entities are found. // Returns a *NotFoundError when no User entities are found.
func (uq *UserQuery) Only(ctx context.Context) (*User, error) { func (_q *UserQuery) Only(ctx context.Context) (*User, error) {
nodes, err := uq.Limit(2).All(setContextOp(ctx, uq.ctx, ent.OpQueryOnly)) nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
if err != nil { if err != nil {
return nil, err 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. // OnlyX is like Only, but panics if an error occurs.
func (uq *UserQuery) OnlyX(ctx context.Context) *User { func (_q *UserQuery) OnlyX(ctx context.Context) *User {
node, err := uq.Only(ctx) node, err := _q.Only(ctx)
if err != nil { if err != nil {
panic(err) 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. // 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 *NotSingularError when more than one User ID is found.
// Returns a *NotFoundError when no entities are 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 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 return
} }
switch len(ids) { 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. // OnlyIDX is like OnlyID, but panics if an error occurs.
func (uq *UserQuery) OnlyIDX(ctx context.Context) int { func (_q *UserQuery) OnlyIDX(ctx context.Context) int {
id, err := uq.OnlyID(ctx) id, err := _q.OnlyID(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -184,18 +184,18 @@ func (uq *UserQuery) OnlyIDX(ctx context.Context) int {
} }
// All executes the query and returns a list of Users. // All executes the query and returns a list of Users.
func (uq *UserQuery) All(ctx context.Context) ([]*User, error) { func (_q *UserQuery) All(ctx context.Context) ([]*User, error) {
ctx = setContextOp(ctx, uq.ctx, ent.OpQueryAll) ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
if err := uq.prepareQuery(ctx); err != nil { if err := _q.prepareQuery(ctx); err != nil {
return nil, err return nil, err
} }
qr := querierAll[[]*User, *UserQuery]() 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. // AllX is like All, but panics if an error occurs.
func (uq *UserQuery) AllX(ctx context.Context) []*User { func (_q *UserQuery) AllX(ctx context.Context) []*User {
nodes, err := uq.All(ctx) nodes, err := _q.All(ctx)
if err != nil { if err != nil {
panic(err) 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. // IDs executes the query and returns a list of User IDs.
func (uq *UserQuery) IDs(ctx context.Context) (ids []int, err error) { func (_q *UserQuery) IDs(ctx context.Context) (ids []int, err error) {
if uq.ctx.Unique == nil && uq.path != nil { if _q.ctx.Unique == nil && _q.path != nil {
uq.Unique(true) _q.Unique(true)
} }
ctx = setContextOp(ctx, uq.ctx, ent.OpQueryIDs) ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
if err = uq.Select(user.FieldID).Scan(ctx, &ids); err != nil { if err = _q.Select(user.FieldID).Scan(ctx, &ids); err != nil {
return nil, err return nil, err
} }
return ids, nil return ids, nil
} }
// IDsX is like IDs, but panics if an error occurs. // IDsX is like IDs, but panics if an error occurs.
func (uq *UserQuery) IDsX(ctx context.Context) []int { func (_q *UserQuery) IDsX(ctx context.Context) []int {
ids, err := uq.IDs(ctx) ids, err := _q.IDs(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -224,17 +224,17 @@ func (uq *UserQuery) IDsX(ctx context.Context) []int {
} }
// Count returns the count of the given query. // Count returns the count of the given query.
func (uq *UserQuery) Count(ctx context.Context) (int, error) { func (_q *UserQuery) Count(ctx context.Context) (int, error) {
ctx = setContextOp(ctx, uq.ctx, ent.OpQueryCount) ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
if err := uq.prepareQuery(ctx); err != nil { if err := _q.prepareQuery(ctx); err != nil {
return 0, err 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. // CountX is like Count, but panics if an error occurs.
func (uq *UserQuery) CountX(ctx context.Context) int { func (_q *UserQuery) CountX(ctx context.Context) int {
count, err := uq.Count(ctx) count, err := _q.Count(ctx)
if err != nil { if err != nil {
panic(err) 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. // Exist returns true if the query has elements in the graph.
func (uq *UserQuery) Exist(ctx context.Context) (bool, error) { func (_q *UserQuery) Exist(ctx context.Context) (bool, error) {
ctx = setContextOp(ctx, uq.ctx, ent.OpQueryExist) ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
switch _, err := uq.FirstID(ctx); { switch _, err := _q.FirstID(ctx); {
case IsNotFound(err): case IsNotFound(err):
return false, nil return false, nil
case err != 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. // ExistX is like Exist, but panics if an error occurs.
func (uq *UserQuery) ExistX(ctx context.Context) bool { func (_q *UserQuery) ExistX(ctx context.Context) bool {
exist, err := uq.Exist(ctx) exist, err := _q.Exist(ctx)
if err != nil { if err != nil {
panic(err) 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 // 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. // used to prepare common query builders and use them differently after the clone is made.
func (uq *UserQuery) Clone() *UserQuery { func (_q *UserQuery) Clone() *UserQuery {
if uq == nil { if _q == nil {
return nil return nil
} }
return &UserQuery{ return &UserQuery{
config: uq.config, config: _q.config,
ctx: uq.ctx.Clone(), ctx: _q.ctx.Clone(),
order: append([]user.OrderOption{}, uq.order...), order: append([]user.OrderOption{}, _q.order...),
inters: append([]Interceptor{}, uq.inters...), inters: append([]Interceptor{}, _q.inters...),
predicates: append([]predicate.User{}, uq.predicates...), predicates: append([]predicate.User{}, _q.predicates...),
withOwner: uq.withOwner.Clone(), withOwner: _q.withOwner.Clone(),
// clone intermediate query. // clone intermediate query.
sql: uq.sql.Clone(), sql: _q.sql.Clone(),
path: uq.path, path: _q.path,
} }
} }
// WithOwner tells the query-builder to eager-load the nodes that are connected to // 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. // the "owner" edge. The optional arguments are used to configure the query builder of the edge.
func (uq *UserQuery) WithOwner(opts ...func(*PasswordTokenQuery)) *UserQuery { func (_q *UserQuery) WithOwner(opts ...func(*PasswordTokenQuery)) *UserQuery {
query := (&PasswordTokenClient{config: uq.config}).Query() query := (&PasswordTokenClient{config: _q.config}).Query()
for _, opt := range opts { for _, opt := range opts {
opt(query) opt(query)
} }
uq.withOwner = query _q.withOwner = query
return uq return _q
} }
// GroupBy is used to group vertices by one or more fields/columns. // 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). // GroupBy(user.FieldName).
// Aggregate(ent.Count()). // Aggregate(ent.Count()).
// Scan(ctx, &v) // Scan(ctx, &v)
func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { func (_q *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy {
uq.ctx.Fields = append([]string{field}, fields...) _q.ctx.Fields = append([]string{field}, fields...)
grbuild := &UserGroupBy{build: uq} grbuild := &UserGroupBy{build: _q}
grbuild.flds = &uq.ctx.Fields grbuild.flds = &_q.ctx.Fields
grbuild.label = user.Label grbuild.label = user.Label
grbuild.scan = grbuild.Scan grbuild.scan = grbuild.Scan
return grbuild return grbuild
@ -328,58 +328,58 @@ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy {
// client.User.Query(). // client.User.Query().
// Select(user.FieldName). // Select(user.FieldName).
// Scan(ctx, &v) // Scan(ctx, &v)
func (uq *UserQuery) Select(fields ...string) *UserSelect { func (_q *UserQuery) Select(fields ...string) *UserSelect {
uq.ctx.Fields = append(uq.ctx.Fields, fields...) _q.ctx.Fields = append(_q.ctx.Fields, fields...)
sbuild := &UserSelect{UserQuery: uq} sbuild := &UserSelect{UserQuery: _q}
sbuild.label = user.Label sbuild.label = user.Label
sbuild.flds, sbuild.scan = &uq.ctx.Fields, sbuild.Scan sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
return sbuild return sbuild
} }
// Aggregate returns a UserSelect configured with the given aggregations. // Aggregate returns a UserSelect configured with the given aggregations.
func (uq *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect { func (_q *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect {
return uq.Select().Aggregate(fns...) return _q.Select().Aggregate(fns...)
} }
func (uq *UserQuery) prepareQuery(ctx context.Context) error { func (_q *UserQuery) prepareQuery(ctx context.Context) error {
for _, inter := range uq.inters { for _, inter := range _q.inters {
if inter == nil { if inter == nil {
return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)") return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
} }
if trv, ok := inter.(Traverser); ok { if trv, ok := inter.(Traverser); ok {
if err := trv.Traverse(ctx, uq); err != nil { if err := trv.Traverse(ctx, _q); err != nil {
return err return err
} }
} }
} }
for _, f := range uq.ctx.Fields { for _, f := range _q.ctx.Fields {
if !user.ValidColumn(f) { if !user.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
} }
} }
if uq.path != nil { if _q.path != nil {
prev, err := uq.path(ctx) prev, err := _q.path(ctx)
if err != nil { if err != nil {
return err return err
} }
uq.sql = prev _q.sql = prev
} }
return nil 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 ( var (
nodes = []*User{} nodes = []*User{}
_spec = uq.querySpec() _spec = _q.querySpec()
loadedTypes = [1]bool{ loadedTypes = [1]bool{
uq.withOwner != nil, _q.withOwner != nil,
} }
) )
_spec.ScanValues = func(columns []string) ([]any, error) { _spec.ScanValues = func(columns []string) ([]any, error) {
return (*User).scanValues(nil, columns) return (*User).scanValues(nil, columns)
} }
_spec.Assign = func(columns []string, values []any) error { _spec.Assign = func(columns []string, values []any) error {
node := &User{config: uq.config} node := &User{config: _q.config}
nodes = append(nodes, node) nodes = append(nodes, node)
node.Edges.loadedTypes = loadedTypes node.Edges.loadedTypes = loadedTypes
return node.assignValues(columns, values) return node.assignValues(columns, values)
@ -387,14 +387,14 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
for i := range hooks { for i := range hooks {
hooks[i](ctx, _spec) 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 return nil, err
} }
if len(nodes) == 0 { if len(nodes) == 0 {
return nodes, nil return nodes, nil
} }
if query := uq.withOwner; query != nil { if query := _q.withOwner; query != nil {
if err := uq.loadOwner(ctx, query, nodes, if err := _q.loadOwner(ctx, query, nodes,
func(n *User) { n.Edges.Owner = []*PasswordToken{} }, func(n *User) { n.Edges.Owner = []*PasswordToken{} },
func(n *User, e *PasswordToken) { n.Edges.Owner = append(n.Edges.Owner, e) }); err != nil { func(n *User, e *PasswordToken) { n.Edges.Owner = append(n.Edges.Owner, e) }); err != nil {
return nil, err return nil, err
@ -403,7 +403,7 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
return nodes, nil 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)) fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[int]*User) nodeids := make(map[int]*User)
for i := range nodes { for i := range nodes {
@ -434,24 +434,24 @@ func (uq *UserQuery) loadOwner(ctx context.Context, query *PasswordTokenQuery, n
return nil return nil
} }
func (uq *UserQuery) sqlCount(ctx context.Context) (int, error) { func (_q *UserQuery) sqlCount(ctx context.Context) (int, error) {
_spec := uq.querySpec() _spec := _q.querySpec()
_spec.Node.Columns = uq.ctx.Fields _spec.Node.Columns = _q.ctx.Fields
if len(uq.ctx.Fields) > 0 { if len(_q.ctx.Fields) > 0 {
_spec.Unique = uq.ctx.Unique != nil && *uq.ctx.Unique _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 := sqlgraph.NewQuerySpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt))
_spec.From = uq.sql _spec.From = _q.sql
if unique := uq.ctx.Unique; unique != nil { if unique := _q.ctx.Unique; unique != nil {
_spec.Unique = *unique _spec.Unique = *unique
} else if uq.path != nil { } else if _q.path != nil {
_spec.Unique = true _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 = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, user.FieldID) _spec.Node.Columns = append(_spec.Node.Columns, user.FieldID)
for i := range fields { 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) { _spec.Predicate = func(selector *sql.Selector) {
for i := range ps { for i := range ps {
ps[i](selector) ps[i](selector)
} }
} }
} }
if limit := uq.ctx.Limit; limit != nil { if limit := _q.ctx.Limit; limit != nil {
_spec.Limit = *limit _spec.Limit = *limit
} }
if offset := uq.ctx.Offset; offset != nil { if offset := _q.ctx.Offset; offset != nil {
_spec.Offset = *offset _spec.Offset = *offset
} }
if ps := uq.order; len(ps) > 0 { if ps := _q.order; len(ps) > 0 {
_spec.Order = func(selector *sql.Selector) { _spec.Order = func(selector *sql.Selector) {
for i := range ps { for i := range ps {
ps[i](selector) ps[i](selector)
@ -483,33 +483,33 @@ func (uq *UserQuery) querySpec() *sqlgraph.QuerySpec {
return _spec return _spec
} }
func (uq *UserQuery) sqlQuery(ctx context.Context) *sql.Selector { func (_q *UserQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(uq.driver.Dialect()) builder := sql.Dialect(_q.driver.Dialect())
t1 := builder.Table(user.Table) t1 := builder.Table(user.Table)
columns := uq.ctx.Fields columns := _q.ctx.Fields
if len(columns) == 0 { if len(columns) == 0 {
columns = user.Columns columns = user.Columns
} }
selector := builder.Select(t1.Columns(columns...)...).From(t1) selector := builder.Select(t1.Columns(columns...)...).From(t1)
if uq.sql != nil { if _q.sql != nil {
selector = uq.sql selector = _q.sql
selector.Select(selector.Columns(columns...)...) selector.Select(selector.Columns(columns...)...)
} }
if uq.ctx.Unique != nil && *uq.ctx.Unique { if _q.ctx.Unique != nil && *_q.ctx.Unique {
selector.Distinct() selector.Distinct()
} }
for _, p := range uq.predicates { for _, p := range _q.predicates {
p(selector) p(selector)
} }
for _, p := range uq.order { for _, p := range _q.order {
p(selector) p(selector)
} }
if offset := uq.ctx.Offset; offset != nil { if offset := _q.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start // limit is mandatory for offset clause. We start
// with default value, and override it below if needed. // with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32) selector.Offset(*offset).Limit(math.MaxInt32)
} }
if limit := uq.ctx.Limit; limit != nil { if limit := _q.ctx.Limit; limit != nil {
selector.Limit(*limit) selector.Limit(*limit)
} }
return selector return selector
@ -522,41 +522,41 @@ type UserGroupBy struct {
} }
// Aggregate adds the given aggregation functions to the group-by query. // Aggregate adds the given aggregation functions to the group-by query.
func (ugb *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy { func (_g *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy {
ugb.fns = append(ugb.fns, fns...) _g.fns = append(_g.fns, fns...)
return ugb return _g
} }
// Scan applies the selector query and scans the result into the given value. // Scan applies the selector query and scans the result into the given value.
func (ugb *UserGroupBy) Scan(ctx context.Context, v any) error { func (_g *UserGroupBy) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, ugb.build.ctx, ent.OpQueryGroupBy) ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
if err := ugb.build.prepareQuery(ctx); err != nil { if err := _g.build.prepareQuery(ctx); err != nil {
return err 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() selector := root.sqlQuery(ctx).Select()
aggregation := make([]string, 0, len(ugb.fns)) aggregation := make([]string, 0, len(_g.fns))
for _, fn := range ugb.fns { for _, fn := range _g.fns {
aggregation = append(aggregation, fn(selector)) aggregation = append(aggregation, fn(selector))
} }
if len(selector.SelectedColumns()) == 0 { if len(selector.SelectedColumns()) == 0 {
columns := make([]string, 0, len(*ugb.flds)+len(ugb.fns)) columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
for _, f := range *ugb.flds { for _, f := range *_g.flds {
columns = append(columns, selector.C(f)) columns = append(columns, selector.C(f))
} }
columns = append(columns, aggregation...) columns = append(columns, aggregation...)
selector.Select(columns...) selector.Select(columns...)
} }
selector.GroupBy(selector.Columns(*ugb.flds...)...) selector.GroupBy(selector.Columns(*_g.flds...)...)
if err := selector.Err(); err != nil { if err := selector.Err(); err != nil {
return err return err
} }
rows := &sql.Rows{} rows := &sql.Rows{}
query, args := selector.Query() 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 return err
} }
defer rows.Close() defer rows.Close()
@ -570,27 +570,27 @@ type UserSelect struct {
} }
// Aggregate adds the given aggregation functions to the selector query. // Aggregate adds the given aggregation functions to the selector query.
func (us *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect { func (_s *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect {
us.fns = append(us.fns, fns...) _s.fns = append(_s.fns, fns...)
return us return _s
} }
// Scan applies the selector query and scans the result into the given value. // Scan applies the selector query and scans the result into the given value.
func (us *UserSelect) Scan(ctx context.Context, v any) error { func (_s *UserSelect) Scan(ctx context.Context, v any) error {
ctx = setContextOp(ctx, us.ctx, ent.OpQuerySelect) ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
if err := us.prepareQuery(ctx); err != nil { if err := _s.prepareQuery(ctx); err != nil {
return err 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) selector := root.sqlQuery(ctx)
aggregation := make([]string, 0, len(us.fns)) aggregation := make([]string, 0, len(_s.fns))
for _, fn := range us.fns { for _, fn := range _s.fns {
aggregation = append(aggregation, fn(selector)) aggregation = append(aggregation, fn(selector))
} }
switch n := len(*us.selector.flds); { switch n := len(*_s.selector.flds); {
case n == 0 && len(aggregation) > 0: case n == 0 && len(aggregation) > 0:
selector.Select(aggregation...) selector.Select(aggregation...)
case n != 0 && len(aggregation) > 0: 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{} rows := &sql.Rows{}
query, args := selector.Query() 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 return err
} }
defer rows.Close() defer rows.Close()

352
ent/user_update.go
View file

@ -23,130 +23,130 @@ type UserUpdate struct {
} }
// Where appends a list predicates to the UserUpdate builder. // Where appends a list predicates to the UserUpdate builder.
func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate { func (_u *UserUpdate) Where(ps ...predicate.User) *UserUpdate {
uu.mutation.Where(ps...) _u.mutation.Where(ps...)
return uu return _u
} }
// SetName sets the "name" field. // SetName sets the "name" field.
func (uu *UserUpdate) SetName(s string) *UserUpdate { func (_u *UserUpdate) SetName(v string) *UserUpdate {
uu.mutation.SetName(s) _u.mutation.SetName(v)
return uu return _u
} }
// SetNillableName sets the "name" field if the given value is not nil. // SetNillableName sets the "name" field if the given value is not nil.
func (uu *UserUpdate) SetNillableName(s *string) *UserUpdate { func (_u *UserUpdate) SetNillableName(v *string) *UserUpdate {
if s != nil { if v != nil {
uu.SetName(*s) _u.SetName(*v)
} }
return uu return _u
} }
// SetEmail sets the "email" field. // SetEmail sets the "email" field.
func (uu *UserUpdate) SetEmail(s string) *UserUpdate { func (_u *UserUpdate) SetEmail(v string) *UserUpdate {
uu.mutation.SetEmail(s) _u.mutation.SetEmail(v)
return uu return _u
} }
// SetNillableEmail sets the "email" field if the given value is not nil. // SetNillableEmail sets the "email" field if the given value is not nil.
func (uu *UserUpdate) SetNillableEmail(s *string) *UserUpdate { func (_u *UserUpdate) SetNillableEmail(v *string) *UserUpdate {
if s != nil { if v != nil {
uu.SetEmail(*s) _u.SetEmail(*v)
} }
return uu return _u
} }
// SetPassword sets the "password" field. // SetPassword sets the "password" field.
func (uu *UserUpdate) SetPassword(s string) *UserUpdate { func (_u *UserUpdate) SetPassword(v string) *UserUpdate {
uu.mutation.SetPassword(s) _u.mutation.SetPassword(v)
return uu return _u
} }
// SetNillablePassword sets the "password" field if the given value is not nil. // SetNillablePassword sets the "password" field if the given value is not nil.
func (uu *UserUpdate) SetNillablePassword(s *string) *UserUpdate { func (_u *UserUpdate) SetNillablePassword(v *string) *UserUpdate {
if s != nil { if v != nil {
uu.SetPassword(*s) _u.SetPassword(*v)
} }
return uu return _u
} }
// SetVerified sets the "verified" field. // SetVerified sets the "verified" field.
func (uu *UserUpdate) SetVerified(b bool) *UserUpdate { func (_u *UserUpdate) SetVerified(v bool) *UserUpdate {
uu.mutation.SetVerified(b) _u.mutation.SetVerified(v)
return uu return _u
} }
// SetNillableVerified sets the "verified" field if the given value is not nil. // SetNillableVerified sets the "verified" field if the given value is not nil.
func (uu *UserUpdate) SetNillableVerified(b *bool) *UserUpdate { func (_u *UserUpdate) SetNillableVerified(v *bool) *UserUpdate {
if b != nil { if v != nil {
uu.SetVerified(*b) _u.SetVerified(*v)
} }
return uu return _u
} }
// SetAdmin sets the "admin" field. // SetAdmin sets the "admin" field.
func (uu *UserUpdate) SetAdmin(b bool) *UserUpdate { func (_u *UserUpdate) SetAdmin(v bool) *UserUpdate {
uu.mutation.SetAdmin(b) _u.mutation.SetAdmin(v)
return uu return _u
} }
// SetNillableAdmin sets the "admin" field if the given value is not nil. // SetNillableAdmin sets the "admin" field if the given value is not nil.
func (uu *UserUpdate) SetNillableAdmin(b *bool) *UserUpdate { func (_u *UserUpdate) SetNillableAdmin(v *bool) *UserUpdate {
if b != nil { if v != nil {
uu.SetAdmin(*b) _u.SetAdmin(*v)
} }
return uu return _u
} }
// AddOwnerIDs adds the "owner" edge to the PasswordToken entity by IDs. // AddOwnerIDs adds the "owner" edge to the PasswordToken entity by IDs.
func (uu *UserUpdate) AddOwnerIDs(ids ...int) *UserUpdate { func (_u *UserUpdate) AddOwnerIDs(ids ...int) *UserUpdate {
uu.mutation.AddOwnerIDs(ids...) _u.mutation.AddOwnerIDs(ids...)
return uu return _u
} }
// AddOwner adds the "owner" edges to the PasswordToken entity. // AddOwner adds the "owner" edges to the PasswordToken entity.
func (uu *UserUpdate) AddOwner(p ...*PasswordToken) *UserUpdate { func (_u *UserUpdate) AddOwner(v ...*PasswordToken) *UserUpdate {
ids := make([]int, len(p)) ids := make([]int, len(v))
for i := range p { for i := range v {
ids[i] = p[i].ID ids[i] = v[i].ID
} }
return uu.AddOwnerIDs(ids...) return _u.AddOwnerIDs(ids...)
} }
// Mutation returns the UserMutation object of the builder. // Mutation returns the UserMutation object of the builder.
func (uu *UserUpdate) Mutation() *UserMutation { func (_u *UserUpdate) Mutation() *UserMutation {
return uu.mutation return _u.mutation
} }
// ClearOwner clears all "owner" edges to the PasswordToken entity. // ClearOwner clears all "owner" edges to the PasswordToken entity.
func (uu *UserUpdate) ClearOwner() *UserUpdate { func (_u *UserUpdate) ClearOwner() *UserUpdate {
uu.mutation.ClearOwner() _u.mutation.ClearOwner()
return uu return _u
} }
// RemoveOwnerIDs removes the "owner" edge to PasswordToken entities by IDs. // RemoveOwnerIDs removes the "owner" edge to PasswordToken entities by IDs.
func (uu *UserUpdate) RemoveOwnerIDs(ids ...int) *UserUpdate { func (_u *UserUpdate) RemoveOwnerIDs(ids ...int) *UserUpdate {
uu.mutation.RemoveOwnerIDs(ids...) _u.mutation.RemoveOwnerIDs(ids...)
return uu return _u
} }
// RemoveOwner removes "owner" edges to PasswordToken entities. // RemoveOwner removes "owner" edges to PasswordToken entities.
func (uu *UserUpdate) RemoveOwner(p ...*PasswordToken) *UserUpdate { func (_u *UserUpdate) RemoveOwner(v ...*PasswordToken) *UserUpdate {
ids := make([]int, len(p)) ids := make([]int, len(v))
for i := range p { for i := range v {
ids[i] = p[i].ID 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. // Save executes the query and returns the number of nodes affected by the update operation.
func (uu *UserUpdate) Save(ctx context.Context) (int, error) { func (_u *UserUpdate) Save(ctx context.Context) (int, error) {
return withHooks(ctx, uu.sqlSave, uu.mutation, uu.hooks) return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
} }
// SaveX is like Save, but panics if an error occurs. // SaveX is like Save, but panics if an error occurs.
func (uu *UserUpdate) SaveX(ctx context.Context) int { func (_u *UserUpdate) SaveX(ctx context.Context) int {
affected, err := uu.Save(ctx) affected, err := _u.Save(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -154,31 +154,31 @@ func (uu *UserUpdate) SaveX(ctx context.Context) int {
} }
// Exec executes the query. // Exec executes the query.
func (uu *UserUpdate) Exec(ctx context.Context) error { func (_u *UserUpdate) Exec(ctx context.Context) error {
_, err := uu.Save(ctx) _, err := _u.Save(ctx)
return err return err
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (uu *UserUpdate) ExecX(ctx context.Context) { func (_u *UserUpdate) ExecX(ctx context.Context) {
if err := uu.Exec(ctx); err != nil { if err := _u.Exec(ctx); err != nil {
panic(err) panic(err)
} }
} }
// check runs all checks and user-defined validators on the builder. // check runs all checks and user-defined validators on the builder.
func (uu *UserUpdate) check() error { func (_u *UserUpdate) check() error {
if v, ok := uu.mutation.Name(); ok { if v, ok := _u.mutation.Name(); ok {
if err := user.NameValidator(v); err != nil { if err := user.NameValidator(v); err != nil {
return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "User.name": %w`, err)} 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 { if err := user.EmailValidator(v); err != nil {
return &ValidationError{Name: "email", err: fmt.Errorf(`ent: validator failed for field "User.email": %w`, err)} 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 { if err := user.PasswordValidator(v); err != nil {
return &ValidationError{Name: "password", err: fmt.Errorf(`ent: validator failed for field "User.password": %w`, err)} 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 return nil
} }
func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { func (_u *UserUpdate) sqlSave(ctx context.Context) (_node int, err error) {
if err := uu.check(); err != nil { if err := _u.check(); err != nil {
return n, err return _node, err
} }
_spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) _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) { _spec.Predicate = func(selector *sql.Selector) {
for i := range ps { for i := range ps {
ps[i](selector) ps[i](selector)
} }
} }
} }
if value, ok := uu.mutation.Name(); ok { if value, ok := _u.mutation.Name(); ok {
_spec.SetField(user.FieldName, field.TypeString, value) _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) _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) _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) _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) _spec.SetField(user.FieldAdmin, field.TypeBool, value)
} }
if uu.mutation.OwnerCleared() { if _u.mutation.OwnerCleared() {
edge := &sqlgraph.EdgeSpec{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M, Rel: sqlgraph.O2M,
Inverse: true, 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) _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{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M, Rel: sqlgraph.O2M,
Inverse: true, 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) _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{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M, Rel: sqlgraph.O2M,
Inverse: true, 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) _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 { if _, ok := err.(*sqlgraph.NotFoundError); ok {
err = &NotFoundError{user.Label} err = &NotFoundError{user.Label}
} else if sqlgraph.IsConstraintError(err) { } else if sqlgraph.IsConstraintError(err) {
@ -266,8 +266,8 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
} }
return 0, err return 0, err
} }
uu.mutation.done = true _u.mutation.done = true
return n, nil return _node, nil
} }
// UserUpdateOne is the builder for updating a single User entity. // UserUpdateOne is the builder for updating a single User entity.
@ -279,137 +279,137 @@ type UserUpdateOne struct {
} }
// SetName sets the "name" field. // SetName sets the "name" field.
func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne { func (_u *UserUpdateOne) SetName(v string) *UserUpdateOne {
uuo.mutation.SetName(s) _u.mutation.SetName(v)
return uuo return _u
} }
// SetNillableName sets the "name" field if the given value is not nil. // SetNillableName sets the "name" field if the given value is not nil.
func (uuo *UserUpdateOne) SetNillableName(s *string) *UserUpdateOne { func (_u *UserUpdateOne) SetNillableName(v *string) *UserUpdateOne {
if s != nil { if v != nil {
uuo.SetName(*s) _u.SetName(*v)
} }
return uuo return _u
} }
// SetEmail sets the "email" field. // SetEmail sets the "email" field.
func (uuo *UserUpdateOne) SetEmail(s string) *UserUpdateOne { func (_u *UserUpdateOne) SetEmail(v string) *UserUpdateOne {
uuo.mutation.SetEmail(s) _u.mutation.SetEmail(v)
return uuo return _u
} }
// SetNillableEmail sets the "email" field if the given value is not nil. // SetNillableEmail sets the "email" field if the given value is not nil.
func (uuo *UserUpdateOne) SetNillableEmail(s *string) *UserUpdateOne { func (_u *UserUpdateOne) SetNillableEmail(v *string) *UserUpdateOne {
if s != nil { if v != nil {
uuo.SetEmail(*s) _u.SetEmail(*v)
} }
return uuo return _u
} }
// SetPassword sets the "password" field. // SetPassword sets the "password" field.
func (uuo *UserUpdateOne) SetPassword(s string) *UserUpdateOne { func (_u *UserUpdateOne) SetPassword(v string) *UserUpdateOne {
uuo.mutation.SetPassword(s) _u.mutation.SetPassword(v)
return uuo return _u
} }
// SetNillablePassword sets the "password" field if the given value is not nil. // SetNillablePassword sets the "password" field if the given value is not nil.
func (uuo *UserUpdateOne) SetNillablePassword(s *string) *UserUpdateOne { func (_u *UserUpdateOne) SetNillablePassword(v *string) *UserUpdateOne {
if s != nil { if v != nil {
uuo.SetPassword(*s) _u.SetPassword(*v)
} }
return uuo return _u
} }
// SetVerified sets the "verified" field. // SetVerified sets the "verified" field.
func (uuo *UserUpdateOne) SetVerified(b bool) *UserUpdateOne { func (_u *UserUpdateOne) SetVerified(v bool) *UserUpdateOne {
uuo.mutation.SetVerified(b) _u.mutation.SetVerified(v)
return uuo return _u
} }
// SetNillableVerified sets the "verified" field if the given value is not nil. // SetNillableVerified sets the "verified" field if the given value is not nil.
func (uuo *UserUpdateOne) SetNillableVerified(b *bool) *UserUpdateOne { func (_u *UserUpdateOne) SetNillableVerified(v *bool) *UserUpdateOne {
if b != nil { if v != nil {
uuo.SetVerified(*b) _u.SetVerified(*v)
} }
return uuo return _u
} }
// SetAdmin sets the "admin" field. // SetAdmin sets the "admin" field.
func (uuo *UserUpdateOne) SetAdmin(b bool) *UserUpdateOne { func (_u *UserUpdateOne) SetAdmin(v bool) *UserUpdateOne {
uuo.mutation.SetAdmin(b) _u.mutation.SetAdmin(v)
return uuo return _u
} }
// SetNillableAdmin sets the "admin" field if the given value is not nil. // SetNillableAdmin sets the "admin" field if the given value is not nil.
func (uuo *UserUpdateOne) SetNillableAdmin(b *bool) *UserUpdateOne { func (_u *UserUpdateOne) SetNillableAdmin(v *bool) *UserUpdateOne {
if b != nil { if v != nil {
uuo.SetAdmin(*b) _u.SetAdmin(*v)
} }
return uuo return _u
} }
// AddOwnerIDs adds the "owner" edge to the PasswordToken entity by IDs. // AddOwnerIDs adds the "owner" edge to the PasswordToken entity by IDs.
func (uuo *UserUpdateOne) AddOwnerIDs(ids ...int) *UserUpdateOne { func (_u *UserUpdateOne) AddOwnerIDs(ids ...int) *UserUpdateOne {
uuo.mutation.AddOwnerIDs(ids...) _u.mutation.AddOwnerIDs(ids...)
return uuo return _u
} }
// AddOwner adds the "owner" edges to the PasswordToken entity. // AddOwner adds the "owner" edges to the PasswordToken entity.
func (uuo *UserUpdateOne) AddOwner(p ...*PasswordToken) *UserUpdateOne { func (_u *UserUpdateOne) AddOwner(v ...*PasswordToken) *UserUpdateOne {
ids := make([]int, len(p)) ids := make([]int, len(v))
for i := range p { for i := range v {
ids[i] = p[i].ID ids[i] = v[i].ID
} }
return uuo.AddOwnerIDs(ids...) return _u.AddOwnerIDs(ids...)
} }
// Mutation returns the UserMutation object of the builder. // Mutation returns the UserMutation object of the builder.
func (uuo *UserUpdateOne) Mutation() *UserMutation { func (_u *UserUpdateOne) Mutation() *UserMutation {
return uuo.mutation return _u.mutation
} }
// ClearOwner clears all "owner" edges to the PasswordToken entity. // ClearOwner clears all "owner" edges to the PasswordToken entity.
func (uuo *UserUpdateOne) ClearOwner() *UserUpdateOne { func (_u *UserUpdateOne) ClearOwner() *UserUpdateOne {
uuo.mutation.ClearOwner() _u.mutation.ClearOwner()
return uuo return _u
} }
// RemoveOwnerIDs removes the "owner" edge to PasswordToken entities by IDs. // RemoveOwnerIDs removes the "owner" edge to PasswordToken entities by IDs.
func (uuo *UserUpdateOne) RemoveOwnerIDs(ids ...int) *UserUpdateOne { func (_u *UserUpdateOne) RemoveOwnerIDs(ids ...int) *UserUpdateOne {
uuo.mutation.RemoveOwnerIDs(ids...) _u.mutation.RemoveOwnerIDs(ids...)
return uuo return _u
} }
// RemoveOwner removes "owner" edges to PasswordToken entities. // RemoveOwner removes "owner" edges to PasswordToken entities.
func (uuo *UserUpdateOne) RemoveOwner(p ...*PasswordToken) *UserUpdateOne { func (_u *UserUpdateOne) RemoveOwner(v ...*PasswordToken) *UserUpdateOne {
ids := make([]int, len(p)) ids := make([]int, len(v))
for i := range p { for i := range v {
ids[i] = p[i].ID ids[i] = v[i].ID
} }
return uuo.RemoveOwnerIDs(ids...) return _u.RemoveOwnerIDs(ids...)
} }
// Where appends a list predicates to the UserUpdate builder. // Where appends a list predicates to the UserUpdate builder.
func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne { func (_u *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne {
uuo.mutation.Where(ps...) _u.mutation.Where(ps...)
return uuo return _u
} }
// Select allows selecting one or more fields (columns) of the returned entity. // Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema. // The default is selecting all fields defined in the entity schema.
func (uuo *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne { func (_u *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne {
uuo.fields = append([]string{field}, fields...) _u.fields = append([]string{field}, fields...)
return uuo return _u
} }
// Save executes the query and returns the updated User entity. // Save executes the query and returns the updated User entity.
func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { func (_u *UserUpdateOne) Save(ctx context.Context) (*User, error) {
return withHooks(ctx, uuo.sqlSave, uuo.mutation, uuo.hooks) return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
} }
// SaveX is like Save, but panics if an error occurs. // SaveX is like Save, but panics if an error occurs.
func (uuo *UserUpdateOne) SaveX(ctx context.Context) *User { func (_u *UserUpdateOne) SaveX(ctx context.Context) *User {
node, err := uuo.Save(ctx) node, err := _u.Save(ctx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -417,31 +417,31 @@ func (uuo *UserUpdateOne) SaveX(ctx context.Context) *User {
} }
// Exec executes the query on the entity. // Exec executes the query on the entity.
func (uuo *UserUpdateOne) Exec(ctx context.Context) error { func (_u *UserUpdateOne) Exec(ctx context.Context) error {
_, err := uuo.Save(ctx) _, err := _u.Save(ctx)
return err return err
} }
// ExecX is like Exec, but panics if an error occurs. // ExecX is like Exec, but panics if an error occurs.
func (uuo *UserUpdateOne) ExecX(ctx context.Context) { func (_u *UserUpdateOne) ExecX(ctx context.Context) {
if err := uuo.Exec(ctx); err != nil { if err := _u.Exec(ctx); err != nil {
panic(err) panic(err)
} }
} }
// check runs all checks and user-defined validators on the builder. // check runs all checks and user-defined validators on the builder.
func (uuo *UserUpdateOne) check() error { func (_u *UserUpdateOne) check() error {
if v, ok := uuo.mutation.Name(); ok { if v, ok := _u.mutation.Name(); ok {
if err := user.NameValidator(v); err != nil { if err := user.NameValidator(v); err != nil {
return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "User.name": %w`, err)} 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 { if err := user.EmailValidator(v); err != nil {
return &ValidationError{Name: "email", err: fmt.Errorf(`ent: validator failed for field "User.email": %w`, err)} 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 { if err := user.PasswordValidator(v); err != nil {
return &ValidationError{Name: "password", err: fmt.Errorf(`ent: validator failed for field "User.password": %w`, err)} 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 return nil
} }
func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) { func (_u *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) {
if err := uuo.check(); err != nil { if err := _u.check(); err != nil {
return _node, err return _node, err
} }
_spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) _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 { if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "User.id" for update`)} return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "User.id" for update`)}
} }
_spec.Node.ID.Value = id _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 = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, user.FieldID) _spec.Node.Columns = append(_spec.Node.Columns, user.FieldID)
for _, f := range fields { 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) { _spec.Predicate = func(selector *sql.Selector) {
for i := range ps { for i := range ps {
ps[i](selector) ps[i](selector)
} }
} }
} }
if value, ok := uuo.mutation.Name(); ok { if value, ok := _u.mutation.Name(); ok {
_spec.SetField(user.FieldName, field.TypeString, value) _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) _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) _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) _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) _spec.SetField(user.FieldAdmin, field.TypeBool, value)
} }
if uuo.mutation.OwnerCleared() { if _u.mutation.OwnerCleared() {
edge := &sqlgraph.EdgeSpec{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M, Rel: sqlgraph.O2M,
Inverse: true, 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) _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{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M, Rel: sqlgraph.O2M,
Inverse: true, 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) _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{ edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M, Rel: sqlgraph.O2M,
Inverse: true, 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) _spec.Edges.Add = append(_spec.Edges.Add, edge)
} }
_node = &User{config: uuo.config} _node = &User{config: _u.config}
_spec.Assign = _node.assignValues _spec.Assign = _node.assignValues
_spec.ScanValues = _node.scanValues _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 { if _, ok := err.(*sqlgraph.NotFoundError); ok {
err = &NotFoundError{user.Label} err = &NotFoundError{user.Label}
} else if sqlgraph.IsConstraintError(err) { } else if sqlgraph.IsConstraintError(err) {
@ -549,6 +549,6 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error)
} }
return nil, err return nil, err
} }
uuo.mutation.done = true _u.mutation.done = true
return _node, nil return _node, nil
} }