diff --git a/backend/db/client.go b/backend/db/client.go index 820cd922..8d703d4d 100644 --- a/backend/db/client.go +++ b/backend/db/client.go @@ -2693,12 +2693,14 @@ func (c *UserIdentityClient) QueryUser(ui *UserIdentity) *UserQuery { // Hooks returns the client hooks. func (c *UserIdentityClient) Hooks() []Hook { - return c.hooks.UserIdentity + hooks := c.hooks.UserIdentity + return append(hooks[:len(hooks):len(hooks)], useridentity.Hooks[:]...) } // Interceptors returns the client interceptors. func (c *UserIdentityClient) Interceptors() []Interceptor { - return c.inters.UserIdentity + inters := c.inters.UserIdentity + return append(inters[:len(inters):len(inters)], useridentity.Interceptors[:]...) } func (c *UserIdentityClient) mutate(ctx context.Context, m *UserIdentityMutation) (Value, error) { diff --git a/backend/db/migrate/schema.go b/backend/db/migrate/schema.go index a071d724..91eb26fe 100644 --- a/backend/db/migrate/schema.go +++ b/backend/db/migrate/schema.go @@ -325,6 +325,7 @@ var ( // UserIdentitiesColumns holds the columns for the "user_identities" table. UserIdentitiesColumns = []*schema.Column{ {Name: "id", Type: field.TypeUUID}, + {Name: "deleted_at", Type: field.TypeTime, Nullable: true}, {Name: "platform", Type: field.TypeString, Default: "email"}, {Name: "identity_id", Type: field.TypeString}, {Name: "union_id", Type: field.TypeString, Nullable: true}, @@ -342,7 +343,7 @@ var ( ForeignKeys: []*schema.ForeignKey{ { Symbol: "user_identities_users_identities", - Columns: []*schema.Column{UserIdentitiesColumns[8]}, + Columns: []*schema.Column{UserIdentitiesColumns[9]}, RefColumns: []*schema.Column{UsersColumns[0]}, OnDelete: schema.SetNull, }, diff --git a/backend/db/mutation.go b/backend/db/mutation.go index 32c1a29c..e57cc5e1 100644 --- a/backend/db/mutation.go +++ b/backend/db/mutation.go @@ -12503,6 +12503,7 @@ type UserIdentityMutation struct { op Op typ string id *uuid.UUID + deleted_at *time.Time platform *consts.UserPlatform identity_id *string union_id *string @@ -12622,6 +12623,55 @@ func (m *UserIdentityMutation) IDs(ctx context.Context) ([]uuid.UUID, error) { } } +// SetDeletedAt sets the "deleted_at" field. +func (m *UserIdentityMutation) SetDeletedAt(t time.Time) { + m.deleted_at = &t +} + +// DeletedAt returns the value of the "deleted_at" field in the mutation. +func (m *UserIdentityMutation) DeletedAt() (r time.Time, exists bool) { + v := m.deleted_at + if v == nil { + return + } + return *v, true +} + +// OldDeletedAt returns the old "deleted_at" field's value of the UserIdentity entity. +// If the UserIdentity object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *UserIdentityMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldDeletedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldDeletedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldDeletedAt: %w", err) + } + return oldValue.DeletedAt, nil +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (m *UserIdentityMutation) ClearDeletedAt() { + m.deleted_at = nil + m.clearedFields[useridentity.FieldDeletedAt] = struct{}{} +} + +// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation. +func (m *UserIdentityMutation) DeletedAtCleared() bool { + _, ok := m.clearedFields[useridentity.FieldDeletedAt] + return ok +} + +// ResetDeletedAt resets all changes to the "deleted_at" field. +func (m *UserIdentityMutation) ResetDeletedAt() { + m.deleted_at = nil + delete(m.clearedFields, useridentity.FieldDeletedAt) +} + // SetUserID sets the "user_id" field. func (m *UserIdentityMutation) SetUserID(u uuid.UUID) { m.user = &u @@ -13036,7 +13086,10 @@ func (m *UserIdentityMutation) Type() string { // order to get all numeric fields that were incremented/decremented, call // AddedFields(). func (m *UserIdentityMutation) Fields() []string { - fields := make([]string, 0, 8) + fields := make([]string, 0, 9) + if m.deleted_at != nil { + fields = append(fields, useridentity.FieldDeletedAt) + } if m.user != nil { fields = append(fields, useridentity.FieldUserID) } @@ -13069,6 +13122,8 @@ func (m *UserIdentityMutation) Fields() []string { // schema. func (m *UserIdentityMutation) Field(name string) (ent.Value, bool) { switch name { + case useridentity.FieldDeletedAt: + return m.DeletedAt() case useridentity.FieldUserID: return m.UserID() case useridentity.FieldPlatform: @@ -13094,6 +13149,8 @@ func (m *UserIdentityMutation) Field(name string) (ent.Value, bool) { // database failed. func (m *UserIdentityMutation) OldField(ctx context.Context, name string) (ent.Value, error) { switch name { + case useridentity.FieldDeletedAt: + return m.OldDeletedAt(ctx) case useridentity.FieldUserID: return m.OldUserID(ctx) case useridentity.FieldPlatform: @@ -13119,6 +13176,13 @@ func (m *UserIdentityMutation) OldField(ctx context.Context, name string) (ent.V // type. func (m *UserIdentityMutation) SetField(name string, value ent.Value) error { switch name { + case useridentity.FieldDeletedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetDeletedAt(v) + return nil case useridentity.FieldUserID: v, ok := value.(uuid.UUID) if !ok { @@ -13205,6 +13269,9 @@ func (m *UserIdentityMutation) AddField(name string, value ent.Value) error { // mutation. func (m *UserIdentityMutation) ClearedFields() []string { var fields []string + if m.FieldCleared(useridentity.FieldDeletedAt) { + fields = append(fields, useridentity.FieldDeletedAt) + } if m.FieldCleared(useridentity.FieldUserID) { fields = append(fields, useridentity.FieldUserID) } @@ -13234,6 +13301,9 @@ func (m *UserIdentityMutation) FieldCleared(name string) bool { // error if the field is not defined in the schema. func (m *UserIdentityMutation) ClearField(name string) error { switch name { + case useridentity.FieldDeletedAt: + m.ClearDeletedAt() + return nil case useridentity.FieldUserID: m.ClearUserID() return nil @@ -13257,6 +13327,9 @@ func (m *UserIdentityMutation) ClearField(name string) error { // It returns an error if the field is not defined in the schema. func (m *UserIdentityMutation) ResetField(name string) error { switch name { + case useridentity.FieldDeletedAt: + m.ResetDeletedAt() + return nil case useridentity.FieldUserID: m.ResetUserID() return nil diff --git a/backend/db/runtime/runtime.go b/backend/db/runtime/runtime.go index 27478ec4..457ad003 100644 --- a/backend/db/runtime/runtime.go +++ b/backend/db/runtime/runtime.go @@ -286,6 +286,11 @@ func init() { userDescUpdatedAt := userFields[8].Descriptor() // user.DefaultUpdatedAt holds the default value on creation for the updated_at field. user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() time.Time) + useridentityMixin := schema.UserIdentity{}.Mixin() + useridentityMixinHooks0 := useridentityMixin[0].Hooks() + useridentity.Hooks[0] = useridentityMixinHooks0[0] + useridentityMixinInters0 := useridentityMixin[0].Interceptors() + useridentity.Interceptors[0] = useridentityMixinInters0[0] useridentityFields := schema.UserIdentity{}.Fields() _ = useridentityFields // useridentityDescPlatform is the schema descriptor for platform field. diff --git a/backend/db/useridentity.go b/backend/db/useridentity.go index 22f4aa49..155150dd 100644 --- a/backend/db/useridentity.go +++ b/backend/db/useridentity.go @@ -20,6 +20,8 @@ type UserIdentity struct { config `json:"-"` // ID of the ent. ID uuid.UUID `json:"id,omitempty"` + // DeletedAt holds the value of the "deleted_at" field. + DeletedAt time.Time `json:"deleted_at,omitempty"` // UserID holds the value of the "user_id" field. UserID uuid.UUID `json:"user_id,omitempty"` // Platform holds the value of the "platform" field. @@ -69,7 +71,7 @@ func (*UserIdentity) scanValues(columns []string) ([]any, error) { switch columns[i] { case useridentity.FieldPlatform, useridentity.FieldIdentityID, useridentity.FieldUnionID, useridentity.FieldNickname, useridentity.FieldEmail, useridentity.FieldAvatarURL: values[i] = new(sql.NullString) - case useridentity.FieldCreatedAt: + case useridentity.FieldDeletedAt, useridentity.FieldCreatedAt: values[i] = new(sql.NullTime) case useridentity.FieldID, useridentity.FieldUserID: values[i] = new(uuid.UUID) @@ -94,6 +96,12 @@ func (ui *UserIdentity) assignValues(columns []string, values []any) error { } else if value != nil { ui.ID = *value } + case useridentity.FieldDeletedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field deleted_at", values[i]) + } else if value.Valid { + ui.DeletedAt = value.Time + } case useridentity.FieldUserID: if value, ok := values[i].(*uuid.UUID); !ok { return fmt.Errorf("unexpected type %T for field user_id", values[i]) @@ -183,6 +191,9 @@ func (ui *UserIdentity) String() string { var builder strings.Builder builder.WriteString("UserIdentity(") builder.WriteString(fmt.Sprintf("id=%v, ", ui.ID)) + builder.WriteString("deleted_at=") + builder.WriteString(ui.DeletedAt.Format(time.ANSIC)) + builder.WriteString(", ") builder.WriteString("user_id=") builder.WriteString(fmt.Sprintf("%v", ui.UserID)) builder.WriteString(", ") diff --git a/backend/db/useridentity/useridentity.go b/backend/db/useridentity/useridentity.go index dd265c89..775b034d 100644 --- a/backend/db/useridentity/useridentity.go +++ b/backend/db/useridentity/useridentity.go @@ -5,6 +5,7 @@ package useridentity import ( "time" + "entgo.io/ent" "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "github.com/chaitin/MonkeyCode/backend/consts" @@ -15,6 +16,8 @@ const ( Label = "user_identity" // FieldID holds the string denoting the id field in the database. FieldID = "id" + // FieldDeletedAt holds the string denoting the deleted_at field in the database. + FieldDeletedAt = "deleted_at" // FieldUserID holds the string denoting the user_id field in the database. FieldUserID = "user_id" // FieldPlatform holds the string denoting the platform field in the database. @@ -47,6 +50,7 @@ const ( // Columns holds all SQL columns for useridentity fields. var Columns = []string{ FieldID, + FieldDeletedAt, FieldUserID, FieldPlatform, FieldIdentityID, @@ -67,7 +71,14 @@ func ValidColumn(column string) bool { return false } +// Note that the variables below are initialized by the runtime +// package on the initialization of the application. Therefore, +// it should be imported in the main as follows: +// +// import _ "github.com/chaitin/MonkeyCode/backend/db/runtime" var ( + Hooks [1]ent.Hook + Interceptors [1]ent.Interceptor // DefaultPlatform holds the default value on creation for the "platform" field. DefaultPlatform consts.UserPlatform // DefaultCreatedAt holds the default value on creation for the "created_at" field. @@ -82,6 +93,11 @@ func ByID(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldID, opts...).ToFunc() } +// ByDeletedAt orders the results by the deleted_at field. +func ByDeletedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldDeletedAt, opts...).ToFunc() +} + // ByUserID orders the results by the user_id field. func ByUserID(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldUserID, opts...).ToFunc() diff --git a/backend/db/useridentity/where.go b/backend/db/useridentity/where.go index e5090274..956cd7fa 100644 --- a/backend/db/useridentity/where.go +++ b/backend/db/useridentity/where.go @@ -57,6 +57,11 @@ func IDLTE(id uuid.UUID) predicate.UserIdentity { return predicate.UserIdentity(sql.FieldLTE(FieldID, id)) } +// DeletedAt applies equality check predicate on the "deleted_at" field. It's identical to DeletedAtEQ. +func DeletedAt(v time.Time) predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldEQ(FieldDeletedAt, v)) +} + // UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ. func UserID(v uuid.UUID) predicate.UserIdentity { return predicate.UserIdentity(sql.FieldEQ(FieldUserID, v)) @@ -98,6 +103,56 @@ func CreatedAt(v time.Time) predicate.UserIdentity { return predicate.UserIdentity(sql.FieldEQ(FieldCreatedAt, v)) } +// DeletedAtEQ applies the EQ predicate on the "deleted_at" field. +func DeletedAtEQ(v time.Time) predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldEQ(FieldDeletedAt, v)) +} + +// DeletedAtNEQ applies the NEQ predicate on the "deleted_at" field. +func DeletedAtNEQ(v time.Time) predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldNEQ(FieldDeletedAt, v)) +} + +// DeletedAtIn applies the In predicate on the "deleted_at" field. +func DeletedAtIn(vs ...time.Time) predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldIn(FieldDeletedAt, vs...)) +} + +// DeletedAtNotIn applies the NotIn predicate on the "deleted_at" field. +func DeletedAtNotIn(vs ...time.Time) predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldNotIn(FieldDeletedAt, vs...)) +} + +// DeletedAtGT applies the GT predicate on the "deleted_at" field. +func DeletedAtGT(v time.Time) predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldGT(FieldDeletedAt, v)) +} + +// DeletedAtGTE applies the GTE predicate on the "deleted_at" field. +func DeletedAtGTE(v time.Time) predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldGTE(FieldDeletedAt, v)) +} + +// DeletedAtLT applies the LT predicate on the "deleted_at" field. +func DeletedAtLT(v time.Time) predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldLT(FieldDeletedAt, v)) +} + +// DeletedAtLTE applies the LTE predicate on the "deleted_at" field. +func DeletedAtLTE(v time.Time) predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldLTE(FieldDeletedAt, v)) +} + +// DeletedAtIsNil applies the IsNil predicate on the "deleted_at" field. +func DeletedAtIsNil() predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldIsNull(FieldDeletedAt)) +} + +// DeletedAtNotNil applies the NotNil predicate on the "deleted_at" field. +func DeletedAtNotNil() predicate.UserIdentity { + return predicate.UserIdentity(sql.FieldNotNull(FieldDeletedAt)) +} + // UserIDEQ applies the EQ predicate on the "user_id" field. func UserIDEQ(v uuid.UUID) predicate.UserIdentity { return predicate.UserIdentity(sql.FieldEQ(FieldUserID, v)) diff --git a/backend/db/useridentity_create.go b/backend/db/useridentity_create.go index 7296bd8d..90644516 100644 --- a/backend/db/useridentity_create.go +++ b/backend/db/useridentity_create.go @@ -26,6 +26,20 @@ type UserIdentityCreate struct { conflict []sql.ConflictOption } +// SetDeletedAt sets the "deleted_at" field. +func (uic *UserIdentityCreate) SetDeletedAt(t time.Time) *UserIdentityCreate { + uic.mutation.SetDeletedAt(t) + return uic +} + +// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil. +func (uic *UserIdentityCreate) SetNillableDeletedAt(t *time.Time) *UserIdentityCreate { + if t != nil { + uic.SetDeletedAt(*t) + } + return uic +} + // SetUserID sets the "user_id" field. func (uic *UserIdentityCreate) SetUserID(u uuid.UUID) *UserIdentityCreate { uic.mutation.SetUserID(u) @@ -148,7 +162,9 @@ func (uic *UserIdentityCreate) Mutation() *UserIdentityMutation { // Save creates the UserIdentity in the database. func (uic *UserIdentityCreate) Save(ctx context.Context) (*UserIdentity, error) { - uic.defaults() + if err := uic.defaults(); err != nil { + return nil, err + } return withHooks(ctx, uic.sqlSave, uic.mutation, uic.hooks) } @@ -175,15 +191,19 @@ func (uic *UserIdentityCreate) ExecX(ctx context.Context) { } // defaults sets the default values of the builder before save. -func (uic *UserIdentityCreate) defaults() { +func (uic *UserIdentityCreate) defaults() error { if _, ok := uic.mutation.Platform(); !ok { v := useridentity.DefaultPlatform uic.mutation.SetPlatform(v) } if _, ok := uic.mutation.CreatedAt(); !ok { + if useridentity.DefaultCreatedAt == nil { + return fmt.Errorf("db: uninitialized useridentity.DefaultCreatedAt (forgotten import db/runtime?)") + } v := useridentity.DefaultCreatedAt() uic.mutation.SetCreatedAt(v) } + return nil } // check runs all checks and user-defined validators on the builder. @@ -233,6 +253,10 @@ func (uic *UserIdentityCreate) createSpec() (*UserIdentity, *sqlgraph.CreateSpec _node.ID = id _spec.ID.Value = &id } + if value, ok := uic.mutation.DeletedAt(); ok { + _spec.SetField(useridentity.FieldDeletedAt, field.TypeTime, value) + _node.DeletedAt = value + } if value, ok := uic.mutation.Platform(); ok { _spec.SetField(useridentity.FieldPlatform, field.TypeString, value) _node.Platform = value @@ -285,7 +309,7 @@ func (uic *UserIdentityCreate) createSpec() (*UserIdentity, *sqlgraph.CreateSpec // of the `INSERT` statement. For example: // // client.UserIdentity.Create(). -// SetUserID(v). +// SetDeletedAt(v). // OnConflict( // // Update the row with the new values // // the was proposed for insertion. @@ -294,7 +318,7 @@ func (uic *UserIdentityCreate) createSpec() (*UserIdentity, *sqlgraph.CreateSpec // // Override some of the fields with custom // // update values. // Update(func(u *ent.UserIdentityUpsert) { -// SetUserID(v+v). +// SetDeletedAt(v+v). // }). // Exec(ctx) func (uic *UserIdentityCreate) OnConflict(opts ...sql.ConflictOption) *UserIdentityUpsertOne { @@ -330,6 +354,24 @@ type ( } ) +// SetDeletedAt sets the "deleted_at" field. +func (u *UserIdentityUpsert) SetDeletedAt(v time.Time) *UserIdentityUpsert { + u.Set(useridentity.FieldDeletedAt, v) + return u +} + +// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create. +func (u *UserIdentityUpsert) UpdateDeletedAt() *UserIdentityUpsert { + u.SetExcluded(useridentity.FieldDeletedAt) + return u +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (u *UserIdentityUpsert) ClearDeletedAt() *UserIdentityUpsert { + u.SetNull(useridentity.FieldDeletedAt) + return u +} + // SetUserID sets the "user_id" field. func (u *UserIdentityUpsert) SetUserID(v uuid.UUID) *UserIdentityUpsert { u.Set(useridentity.FieldUserID, v) @@ -504,6 +546,27 @@ func (u *UserIdentityUpsertOne) Update(set func(*UserIdentityUpsert)) *UserIdent return u } +// SetDeletedAt sets the "deleted_at" field. +func (u *UserIdentityUpsertOne) SetDeletedAt(v time.Time) *UserIdentityUpsertOne { + return u.Update(func(s *UserIdentityUpsert) { + s.SetDeletedAt(v) + }) +} + +// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create. +func (u *UserIdentityUpsertOne) UpdateDeletedAt() *UserIdentityUpsertOne { + return u.Update(func(s *UserIdentityUpsert) { + s.UpdateDeletedAt() + }) +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (u *UserIdentityUpsertOne) ClearDeletedAt() *UserIdentityUpsertOne { + return u.Update(func(s *UserIdentityUpsert) { + s.ClearDeletedAt() + }) +} + // SetUserID sets the "user_id" field. func (u *UserIdentityUpsertOne) SetUserID(v uuid.UUID) *UserIdentityUpsertOne { return u.Update(func(s *UserIdentityUpsert) { @@ -787,7 +850,7 @@ func (uicb *UserIdentityCreateBulk) ExecX(ctx context.Context) { // // Override some of the fields with custom // // update values. // Update(func(u *ent.UserIdentityUpsert) { -// SetUserID(v+v). +// SetDeletedAt(v+v). // }). // Exec(ctx) func (uicb *UserIdentityCreateBulk) OnConflict(opts ...sql.ConflictOption) *UserIdentityUpsertBulk { @@ -866,6 +929,27 @@ func (u *UserIdentityUpsertBulk) Update(set func(*UserIdentityUpsert)) *UserIden return u } +// SetDeletedAt sets the "deleted_at" field. +func (u *UserIdentityUpsertBulk) SetDeletedAt(v time.Time) *UserIdentityUpsertBulk { + return u.Update(func(s *UserIdentityUpsert) { + s.SetDeletedAt(v) + }) +} + +// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create. +func (u *UserIdentityUpsertBulk) UpdateDeletedAt() *UserIdentityUpsertBulk { + return u.Update(func(s *UserIdentityUpsert) { + s.UpdateDeletedAt() + }) +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (u *UserIdentityUpsertBulk) ClearDeletedAt() *UserIdentityUpsertBulk { + return u.Update(func(s *UserIdentityUpsert) { + s.ClearDeletedAt() + }) +} + // SetUserID sets the "user_id" field. func (u *UserIdentityUpsertBulk) SetUserID(v uuid.UUID) *UserIdentityUpsertBulk { return u.Update(func(s *UserIdentityUpsert) { diff --git a/backend/db/useridentity_query.go b/backend/db/useridentity_query.go index 48b17697..760e4d89 100644 --- a/backend/db/useridentity_query.go +++ b/backend/db/useridentity_query.go @@ -302,12 +302,12 @@ func (uiq *UserIdentityQuery) WithUser(opts ...func(*UserQuery)) *UserIdentityQu // Example: // // var v []struct { -// UserID uuid.UUID `json:"user_id,omitempty"` +// DeletedAt time.Time `json:"deleted_at,omitempty"` // Count int `json:"count,omitempty"` // } // // client.UserIdentity.Query(). -// GroupBy(useridentity.FieldUserID). +// GroupBy(useridentity.FieldDeletedAt). // Aggregate(db.Count()). // Scan(ctx, &v) func (uiq *UserIdentityQuery) GroupBy(field string, fields ...string) *UserIdentityGroupBy { @@ -325,11 +325,11 @@ func (uiq *UserIdentityQuery) GroupBy(field string, fields ...string) *UserIdent // Example: // // var v []struct { -// UserID uuid.UUID `json:"user_id,omitempty"` +// DeletedAt time.Time `json:"deleted_at,omitempty"` // } // // client.UserIdentity.Query(). -// Select(useridentity.FieldUserID). +// Select(useridentity.FieldDeletedAt). // Scan(ctx, &v) func (uiq *UserIdentityQuery) Select(fields ...string) *UserIdentitySelect { uiq.ctx.Fields = append(uiq.ctx.Fields, fields...) diff --git a/backend/db/useridentity_update.go b/backend/db/useridentity_update.go index 235ac9f8..fc21a5fc 100644 --- a/backend/db/useridentity_update.go +++ b/backend/db/useridentity_update.go @@ -32,6 +32,26 @@ func (uiu *UserIdentityUpdate) Where(ps ...predicate.UserIdentity) *UserIdentity return uiu } +// SetDeletedAt sets the "deleted_at" field. +func (uiu *UserIdentityUpdate) SetDeletedAt(t time.Time) *UserIdentityUpdate { + uiu.mutation.SetDeletedAt(t) + return uiu +} + +// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil. +func (uiu *UserIdentityUpdate) SetNillableDeletedAt(t *time.Time) *UserIdentityUpdate { + if t != nil { + uiu.SetDeletedAt(*t) + } + return uiu +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (uiu *UserIdentityUpdate) ClearDeletedAt() *UserIdentityUpdate { + uiu.mutation.ClearDeletedAt() + return uiu +} + // SetUserID sets the "user_id" field. func (uiu *UserIdentityUpdate) SetUserID(u uuid.UUID) *UserIdentityUpdate { uiu.mutation.SetUserID(u) @@ -232,6 +252,12 @@ func (uiu *UserIdentityUpdate) sqlSave(ctx context.Context) (n int, err error) { } } } + if value, ok := uiu.mutation.DeletedAt(); ok { + _spec.SetField(useridentity.FieldDeletedAt, field.TypeTime, value) + } + if uiu.mutation.DeletedAtCleared() { + _spec.ClearField(useridentity.FieldDeletedAt, field.TypeTime) + } if value, ok := uiu.mutation.Platform(); ok { _spec.SetField(useridentity.FieldPlatform, field.TypeString, value) } @@ -316,6 +342,26 @@ type UserIdentityUpdateOne struct { modifiers []func(*sql.UpdateBuilder) } +// SetDeletedAt sets the "deleted_at" field. +func (uiuo *UserIdentityUpdateOne) SetDeletedAt(t time.Time) *UserIdentityUpdateOne { + uiuo.mutation.SetDeletedAt(t) + return uiuo +} + +// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil. +func (uiuo *UserIdentityUpdateOne) SetNillableDeletedAt(t *time.Time) *UserIdentityUpdateOne { + if t != nil { + uiuo.SetDeletedAt(*t) + } + return uiuo +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (uiuo *UserIdentityUpdateOne) ClearDeletedAt() *UserIdentityUpdateOne { + uiuo.mutation.ClearDeletedAt() + return uiuo +} + // SetUserID sets the "user_id" field. func (uiuo *UserIdentityUpdateOne) SetUserID(u uuid.UUID) *UserIdentityUpdateOne { uiuo.mutation.SetUserID(u) @@ -546,6 +592,12 @@ func (uiuo *UserIdentityUpdateOne) sqlSave(ctx context.Context) (_node *UserIden } } } + if value, ok := uiuo.mutation.DeletedAt(); ok { + _spec.SetField(useridentity.FieldDeletedAt, field.TypeTime, value) + } + if uiuo.mutation.DeletedAtCleared() { + _spec.ClearField(useridentity.FieldDeletedAt, field.TypeTime) + } if value, ok := uiuo.mutation.Platform(); ok { _spec.SetField(useridentity.FieldPlatform, field.TypeString, value) } diff --git a/backend/ent/schema/useridentity.go b/backend/ent/schema/useridentity.go index caa59306..c2f7560b 100644 --- a/backend/ent/schema/useridentity.go +++ b/backend/ent/schema/useridentity.go @@ -11,6 +11,7 @@ import ( "github.com/google/uuid" "github.com/chaitin/MonkeyCode/backend/consts" + "github.com/chaitin/MonkeyCode/backend/pkg/entx" ) // UserIdentity holds the schema definition for the UserIdentity entity. @@ -18,6 +19,12 @@ type UserIdentity struct { ent.Schema } +func (UserIdentity) Mixin() []ent.Mixin { + return []ent.Mixin{ + entx.SoftDeleteMixin{}, + } +} + func (UserIdentity) Annotations() []schema.Annotation { return []schema.Annotation{ entsql.Annotation{ diff --git a/backend/migration/000002_create_core_table.up.sql b/backend/migration/000002_create_core_table.up.sql index 0fd19d0a..40df9c35 100644 --- a/backend/migration/000002_create_core_table.up.sql +++ b/backend/migration/000002_create_core_table.up.sql @@ -31,8 +31,8 @@ CREATE TABLE IF NOT EXISTS users ( deleted_at TIMESTAMPTZ ); -CREATE UNIQUE INDEX IF NOT EXISTS unique_idx_users_username ON users (username) WHERE username IS NOT NULL; -CREATE UNIQUE INDEX IF NOT EXISTS unique_idx_users_email ON users (email) WHERE email IS NOT NULL; +CREATE UNIQUE INDEX IF NOT EXISTS unique_idx_users_username ON users (username) WHERE deleted_at IS NULL AND username != ''; +CREATE UNIQUE INDEX IF NOT EXISTS unique_idx_users_email ON users (email) WHERE deleted_at IS NULL AND email != ''; CREATE TABLE IF NOT EXISTS user_identities ( id UUID PRIMARY KEY DEFAULT uuid_generate_v1(), @@ -43,10 +43,11 @@ CREATE TABLE IF NOT EXISTS user_identities ( nickname VARCHAR(255), email VARCHAR(255), avatar_url TEXT, - created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP + created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP, + deleted_at TIMESTAMPTZ ); -CREATE UNIQUE INDEX IF NOT EXISTS unique_idx_user_identities_platform_identity_id ON user_identities (platform, identity_id); +CREATE UNIQUE INDEX IF NOT EXISTS unique_idx_user_identities_platform_identity_id ON user_identities (platform, identity_id) WHERE deleted_at IS NULL; CREATE TABLE IF NOT EXISTS user_login_histories ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(),