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 BlobFunc

            type BlobFunc func(context.Context, *ent.BlobMutation) (ent.Value, error)

              The BlobFunc type is an adapter to allow the use of ordinary function as Blob mutator.

              func (BlobFunc) Mutate

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

                Mutate calls f(ctx, m).

                type CarFunc

                type CarFunc func(context.Context, *ent.CarMutation) (ent.Value, error)

                  The CarFunc type is an adapter to allow the use of ordinary function as Car mutator.

                  func (CarFunc) Mutate

                  func (f CarFunc) 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 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 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 MixinIDFunc

                                                  type MixinIDFunc func(context.Context, *ent.MixinIDMutation) (ent.Value, error)

                                                    The MixinIDFunc type is an adapter to allow the use of ordinary function as MixinID mutator.

                                                    func (MixinIDFunc) Mutate

                                                    func (f MixinIDFunc) 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 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