snapshot of https://github.com/ent/ent.git (master, 2026-09-15; blobs > 131072B omitted)

entc/gen/template/builder/mutation_graph.tmpl

@@ -0,0 +1,213 @@
+{{/*
+Copyright 2019-present Facebook Inc. All rights reserved.
+This source code is licensed under the Apache 2.0 license found
+in the LICENSE file in the root directory of this source tree.
+*/}}
+
+{{/* gotype: entgo.io/ent/entc/gen.Graph */}}
+
+{{ define "mutation_graph" }}
+
+{{ $pkg := base $.Config.Package }}
+{{ template "header" $ }}
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+
+	{{- range $n := $.Nodes }}
+		{{ $n.PackageAlias }} "{{ $.Config.Package }}/{{ $n.PackageDir }}"
+		{{- template "import/types" $n }}
+	{{- end }}
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+)
+
+const (
+	// Operation types.
+	OpCreate	= ent.OpCreate
+	OpDelete	= ent.OpDelete
+	OpDeleteOne	= ent.OpDeleteOne
+	OpUpdate	= ent.OpUpdate
+	OpUpdateOne	= ent.OpUpdateOne
+
+	// Node types.
+	{{- range $n := $.Nodes }}
+		{{ $n.TypeName }} = "{{ $n.Name }}"
+	{{- end }}
+)
+
+{{ range $n := $.MutableNodes }}
+
+{{ $mutation := $n.MutationName }}
+{{ $baseMutation := print $n.Package ".Mutation" }}
+// {{ $mutation }} represents an operation that mutates the {{ $n.Name }} nodes in the graph.
+type {{ $mutation }} struct {
+	{{ $baseMutation }}
+	config
+	{{- with $n.HasOneFieldID }}
+		{{ $n.ID.BuilderField }} *{{ $n.ID.Type }}
+	{{- end }}
+	done bool
+	oldValue func(context.Context) (*{{ $n.Name }}, error)
+}
+
+var _ ent.Mutation = (*{{ $mutation }})(nil)
+
+{{ $mutationOption := print (camel $n.Name) "Option" }}
+// {{ $mutationOption }} allows management of the mutation configuration using functional options.
+type {{ $mutationOption }} func(*{{ $mutation }})
+
+// new{{ $mutation }} creates new mutation for the {{ $n.Name }} entity.
+func new{{ $mutation }}(c config, op Op, opts ...{{ $mutationOption }}) *{{ $mutation }} {
+	m := &{{ $mutation }}{
+		Mutation: *{{ $n.Package }}.NewMutation(op),
+		config: c,
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+{{ with $n.HasOneFieldID }}
+	{{ if $n.ID.UserDefined }}
+		// SetID sets the value of the id field. Note that this
+		// operation is only accepted on creation of {{ $n.Name }} entities.
+		func (m *{{ $mutation }}) SetID(id {{ $n.ID.Type }}) {
+			m.{{ $n.ID.BuilderField }} = &id
+		}
+	{{ end }}
+
+	// ID returns the ID value in the mutation. Note that the ID is only available
+	// if it was provided to the builder or after it was returned from the database.
+	func (m *{{ $mutation }}) ID() (id {{ $n.ID.Type }}, exists bool) {
+		if m.{{ $n.ID.BuilderField }} == nil {
+			return
+		}
+		return *m.{{ $n.ID.BuilderField }}, true
+	}
+
+	{{ $opt := print "with" $n.Name "ID" }}
+	// {{ $opt }} sets the ID field of the mutation.
+	func {{ $opt }}(id {{ $n.ID.Type }}) {{ $mutationOption }} {
+		return func(m *{{ $mutation }}) {
+			var (
+				err error
+				once sync.Once
+				value *{{ $n.Name }}
+			)
+			m.oldValue = func(ctx context.Context) (*{{ $n.Name }}, error) {
+				once.Do(func() {
+					if m.done {
+						err = errors.New("querying old values post mutation is not allowed")
+					} else {
+						value, err = m.Client().{{ $n.Name }}.Get(ctx, id)
+					}
+				})
+				return value, err
+			}
+			m.{{ $n.ID.BuilderField }} = &id
+		}
+	}
+
+	{{ $opt = print "with" $n.Name }}
+	// {{ $opt }} sets the old {{ $n.Name }} of the mutation.
+	func {{ $opt }}(node *{{ $n.Name }}) {{ $mutationOption }} {
+		return func(m *{{ $mutation }}) {
+			m.oldValue = func(context.Context) (*{{ $n.Name }}, error) {
+				return node, nil
+			}
+			m.{{ $n.ID.BuilderField }} = &node.ID
+		}
+	}
+{{ end }}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m {{ $mutation }}) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m {{ $mutation }}) Tx() (*Tx, error) {
+	if 	_, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("{{ $pkg }}: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+{{ with $n.HasOneFieldID }}
+	// IDs queries the database and returns the entity ids that match the mutation's predicate.
+	// That means, if the mutation is applied within a transaction with an isolation level such
+	// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+	// or updated by the mutation.
+	func (m *{{ $mutation }}) IDs(ctx context.Context) ([]{{ $n.ID.Type }}, error) {
+		switch {
+		case m.Op().Is(OpUpdateOne | OpDeleteOne):
+			id, exists := m.ID()
+			if exists {
+				return []{{ $n.ID.Type }}{id}, nil
+			}
+			fallthrough
+		case m.Op().Is(OpUpdate | OpDelete):
+			return m.Client().{{ $n.Name }}.Query().Where(m.Predicates()...).IDs(ctx)
+		default:
+			return nil, fmt.Errorf("IDs is not allowed on %s operations", m.Op())
+		}
+	}
+{{ end }}
+
+{{ range $f := $n.Fields }}
+	{{- if $f.IsBlobLazy }}{{ continue }}{{ end }}
+	{{ if $n.HasOneFieldID }}
+		{{ $const := print $n.Package "." $f.Constant }}
+		// {{ $f.MutationGetOld }} returns the old "{{ $f.Name }}" field's value of the {{ $n.Name }} entity.
+		// If the {{ $n.Name }} 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 *{{ $mutation }}) {{ $f.MutationGetOld }}(ctx context.Context) (v {{ if $f.NillableValue }}*{{ end }}{{ $f.Type }}, err error) {
+			if !m.Op().Is(OpUpdateOne) {
+				return v, errors.New("{{ $f.MutationGetOld }} is only allowed on UpdateOne operations")
+			}
+			if _, exists := m.ID(); !exists || m.oldValue == nil {
+				return v, errors.New("{{ $f.MutationGetOld }} requires an ID field in the mutation")
+			}
+			oldValue, err := m.oldValue(ctx)
+			if err != nil {
+				return v, fmt.Errorf("querying old value for {{ $f.MutationGetOld }}: %w", err)
+			}
+			return oldValue.{{ $f.StructField }}, nil
+		}
+	{{ end }}
+{{ end }}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *{{ $mutation }}) OldField(ctx context.Context, name string) (ent.Value, error) {
+	{{- if $n.HasCompositeID }}
+		return nil, errors.New("edge schema {{ $n.Name }} does not support getting old values")
+	{{- else }}
+		{{- with $n.Fields }}
+			switch name {
+			{{- range $f := . }}
+				{{- if $f.IsBlobLazy }}{{ continue }}{{ end }}
+				{{- $const := print $n.Package "." $f.Constant }}
+				case {{ $const }}:
+					return m.{{ $f.MutationGetOld }}(ctx)
+			{{- end }}
+			}
+		{{- end }}
+		return nil, fmt.Errorf("unknown {{ $n.Name }} field %s", name)
+	{{- end }}
+}
+{{ end }}
+
+{{ end }}