Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func FixedError

func FixedError(err error) ent.Hook

    FixedError is a hook returning a fixed error.

    func If

    func If(hk ent.Hook, cond Condition) ent.Hook

      If executes the given hook under condition.

      hook.If(ComputeAverage, And(HasFields(...), HasAddedFields(...)))
      

      func On

      func On(hk ent.Hook, op ent.Op) ent.Hook

        On executes the given hook only for the given operation.

        hook.On(Log, ent.Delete|ent.Create)
        

        func Reject

        func Reject(op ent.Op) ent.Hook

          Reject returns a hook that rejects all operations that match op.

          func (T) Hooks() []ent.Hook {
          	return []ent.Hook{
          		Reject(ent.Delete|ent.Update),
          	}
          }
          

          func Unless

          func Unless(hk ent.Hook, op ent.Op) ent.Hook

            Unless skips the given hook only for the given operation.

            hook.Unless(Log, ent.Update|ent.UpdateOne)
            

            Types

            type CardFunc

            type CardFunc func(context.Context, *ent.CardMutation) (ent.Value, error)

              The CardFunc type is an adapter to allow the use of ordinary function as Card mutator.

              func (CardFunc) Mutate

              func (f CardFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                Mutate calls f(ctx, m).

                type Chain

                type Chain struct {
                	// contains filtered or unexported fields
                }

                  Chain acts as a list of hooks and is effectively immutable. Once created, it will always hold the same set of hooks in the same order.

                  func NewChain

                  func NewChain(hooks ...ent.Hook) Chain

                    NewChain creates a new chain of hooks.

                    func (Chain) Append

                    func (c Chain) Append(hooks ...ent.Hook) Chain

                      Append extends a chain, adding the specified hook as the last ones in the mutation flow.

                      func (Chain) Extend

                      func (c Chain) Extend(chain Chain) Chain

                        Extend extends a chain, adding the specified chain as the last ones in the mutation flow.

                        func (Chain) Hook

                        func (c Chain) Hook() ent.Hook

                          Hook chains the list of hooks and returns the final hook.

                          type CommentFunc

                          type CommentFunc func(context.Context, *ent.CommentMutation) (ent.Value, error)

                            The CommentFunc type is an adapter to allow the use of ordinary function as Comment mutator.

                            func (CommentFunc) Mutate

                            func (f CommentFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                              Mutate calls f(ctx, m).

                              type Condition

                              type Condition func(context.Context, ent.Mutation) bool

                                Condition is a hook condition function.

                                func And

                                func And(first, second Condition, rest ...Condition) Condition

                                  And groups conditions with the AND operator.

                                  func HasAddedFields

                                  func HasAddedFields(field string, fields ...string) Condition

                                    HasAddedFields is a condition validating `.AddedField` on fields.

                                    func HasClearedFields

                                    func HasClearedFields(field string, fields ...string) Condition

                                      HasClearedFields is a condition validating `.FieldCleared` on fields.

                                      func HasFields

                                      func HasFields(field string, fields ...string) Condition

                                        HasFields is a condition validating `.Field` on fields.

                                        func HasOp

                                        func HasOp(op ent.Op) Condition

                                          HasOp is a condition testing mutation operation.

                                          func Not

                                          func Not(cond Condition) Condition

                                            Not negates a given condition.

                                            func Or

                                            func Or(first, second Condition, rest ...Condition) Condition

                                              Or groups conditions with the OR operator.

                                              type FieldTypeFunc

                                              type FieldTypeFunc func(context.Context, *ent.FieldTypeMutation) (ent.Value, error)

                                                The FieldTypeFunc type is an adapter to allow the use of ordinary function as FieldType mutator.

                                                func (FieldTypeFunc) Mutate

                                                func (f FieldTypeFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                  Mutate calls f(ctx, m).

                                                  type FileFunc

                                                  type FileFunc func(context.Context, *ent.FileMutation) (ent.Value, error)

                                                    The FileFunc type is an adapter to allow the use of ordinary function as File mutator.

                                                    func (FileFunc) Mutate

                                                    func (f FileFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                      Mutate calls f(ctx, m).

                                                      type FileTypeFunc

                                                      type FileTypeFunc func(context.Context, *ent.FileTypeMutation) (ent.Value, error)

                                                        The FileTypeFunc type is an adapter to allow the use of ordinary function as FileType mutator.

                                                        func (FileTypeFunc) Mutate

                                                        func (f FileTypeFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                          Mutate calls f(ctx, m).

                                                          type GoodsFunc

                                                          type GoodsFunc func(context.Context, *ent.GoodsMutation) (ent.Value, error)

                                                            The GoodsFunc type is an adapter to allow the use of ordinary function as Goods mutator.

                                                            func (GoodsFunc) Mutate

                                                            func (f GoodsFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                              Mutate calls f(ctx, m).

                                                              type GroupFunc

                                                              type GroupFunc func(context.Context, *ent.GroupMutation) (ent.Value, error)

                                                                The GroupFunc type is an adapter to allow the use of ordinary function as Group mutator.

                                                                func (GroupFunc) Mutate

                                                                func (f GroupFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                                  Mutate calls f(ctx, m).

                                                                  type GroupInfoFunc

                                                                  type GroupInfoFunc func(context.Context, *ent.GroupInfoMutation) (ent.Value, error)

                                                                    The GroupInfoFunc type is an adapter to allow the use of ordinary function as GroupInfo mutator.

                                                                    func (GroupInfoFunc) Mutate

                                                                    func (f GroupInfoFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                                      Mutate calls f(ctx, m).

                                                                      type ItemFunc

                                                                      type ItemFunc func(context.Context, *ent.ItemMutation) (ent.Value, error)

                                                                        The ItemFunc type is an adapter to allow the use of ordinary function as Item mutator.

                                                                        func (ItemFunc) Mutate

                                                                        func (f ItemFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                                          Mutate calls f(ctx, m).

                                                                          type NodeFunc

                                                                          type NodeFunc func(context.Context, *ent.NodeMutation) (ent.Value, error)

                                                                            The NodeFunc type is an adapter to allow the use of ordinary function as Node mutator.

                                                                            func (NodeFunc) Mutate

                                                                            func (f NodeFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                                              Mutate calls f(ctx, m).

                                                                              type PetFunc

                                                                              type PetFunc func(context.Context, *ent.PetMutation) (ent.Value, error)

                                                                                The PetFunc type is an adapter to allow the use of ordinary function as Pet mutator.

                                                                                func (PetFunc) Mutate

                                                                                func (f PetFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                                                  Mutate calls f(ctx, m).

                                                                                  type SpecFunc

                                                                                  type SpecFunc func(context.Context, *ent.SpecMutation) (ent.Value, error)

                                                                                    The SpecFunc type is an adapter to allow the use of ordinary function as Spec mutator.

                                                                                    func (SpecFunc) Mutate

                                                                                    func (f SpecFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                                                      Mutate calls f(ctx, m).

                                                                                      type TaskFunc

                                                                                      type TaskFunc func(context.Context, *ent.TaskMutation) (ent.Value, error)

                                                                                        The TaskFunc type is an adapter to allow the use of ordinary function as Task mutator.

                                                                                        func (TaskFunc) Mutate

                                                                                        func (f TaskFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                                                          Mutate calls f(ctx, m).

                                                                                          type UserFunc

                                                                                          type UserFunc func(context.Context, *ent.UserMutation) (ent.Value, error)

                                                                                            The UserFunc type is an adapter to allow the use of ordinary function as User mutator.

                                                                                            func (UserFunc) Mutate

                                                                                            func (f UserFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error)

                                                                                              Mutate calls f(ctx, m).

                                                                                              Source Files