stdent

func AttemptFromContext ¶ added in v0.0.50

func AttemptFromContext(ctx context.Context) int

AttemptFromContext returns which execution attempt it is. Panics if this information is not present.

func ContextWithAttempts ¶ added in v0.0.50

func ContextWithAttempts(ctx context.Context, v int) context.Context

ContextWithAttempts stores which execution attempt it is.

func ContextWithTx ¶ added in v0.0.50

func ContextWithTx[T Tx](ctx context.Context, tx T) context.Context

ContextWithTx returns a context with the Tx in it.

func HasReadPromotion ¶ added in v0.0.235

func HasReadPromotion(ctx context.Context) bool

HasReadPromotion reports whether ctx was stamped by WithReadPromotion. Consumers normally don't call this directly — TransactR / TransactR0 consult it on every invocation — but it is exported for tests and for diagnostics (e.g. attaching the decision to a span).

func NoTestForMaxQueryPlanCosts ¶ added in v0.0.91

func NoTestForMaxQueryPlanCosts(ctx context.Context) bool

NoTestForMaxQueryPlanCosts returns whether the cost check is disabled.

func Transact0 ¶ added in v0.0.50

func Transact0[T Tx](
	ctx context.Context,
	txr *Transactor[T],
	fnc func(ctx context.Context, tx T) error,
) (err error)

Transact0 runs Transact1 but without a value to return.

func Transact1 ¶ added in v0.0.50

func Transact1[T Tx, U any](
	ctx context.Context,
	txr *Transactor[T],
	fnc func(ctx context.Context, tx T) (U, error),
) (res U, err error)

Transact1 runs fnc in a transaction T derived from the provided Ent client while returning one value of type U. The implementation is taken from the official docs: https://entgo.io/docs/transactions#best-practices. If the context already has a transaction, it runs it in that one.

func TransactR ¶ added in v0.0.235

func TransactR[T Tx, I any, O any, IP interface{ *I }, OP interface{ *O }](
	ctx context.Context,
	ro, rw *Transactor[T],
	inp IP,
	fn func(ctx context.Context, tx T, inp IP) (OP, error),
) (OP, error)

TransactR is Transact1 for read-bound callers that may, per invocation, be transparently promoted to the writer to give the caller read-your-writes consistency. The choice is driven by HasReadPromotion on ctx and forwards to Transact1 with the chosen transactor, so every guarantee Transact1 provides (retry-on-serialization-failure, nested-tx reuse, panic rollback) applies unchanged.

Callers that bind their handler to ONE boundary at proto-gen / compile time can still pass both `ro` and `rw` here without leaking the routing policy into generated code or into the handler body.

The inp / fn shape (taking a typed input + returning a typed output) mirrors common request/response transactional helpers.

func TransactR0 ¶ added in v0.0.235

func TransactR0[T Tx](
	ctx context.Context,
	ro, rw *Transactor[T],
	fn func(ctx context.Context, tx T) error,
) error

TransactR0 is TransactR for the common case where the inner function neither needs a typed input nor returns a typed output; mirrors Transact0 exactly, including all of its safety guarantees, and chooses the transactor the same way TransactR does.

func TxFromContext ¶ added in v0.0.50

func TxFromContext[T Tx](ctx context.Context) T

TxFromContext will get a transaction of type T from the context or panic.

func WithNoTestForMaxQueryPlanCosts ¶ added in v0.0.91

func WithNoTestForMaxQueryPlanCosts(ctx context.Context) context.Context

WithNoTestForMaxQueryPlanCosts allow disabling the plan cost check.

func WithReadPromotion ¶ added in v0.0.235

func WithReadPromotion(ctx context.Context) context.Context

WithReadPromotion stamps ctx so that a subsequent TransactR or TransactR0 call will open its transaction against the read-write transactor instead of the read-only one. It is the single seam where read-your-writes routing policy plugs in — e.g. an HTTP middleware that observes a signed "write fence" cookie set after a recent write, or any caller that knows it needs the writer for a specific invocation.

The decision is invisible to the developer-implemented handler body: it still receives a single T and has no way to widen its own posture (downstream concerns like per-tenant Postgres roles and transaction mode continue to enforce what the caller may do).

func WithWriteObserver ¶ added in v0.0.235

func WithWriteObserver(ctx context.Context) (context.Context, *atomic.Bool)

WithWriteObserver attaches a fresh write observer to ctx and returns both the derived ctx and the same *atomic.Bool that the stdent transact layer will flip on the first successful commit of a non-read-only transaction within ctx's lifetime.

It exists because context.Context only flows downward: a plain bool stamped by Transact1 would be invisible to a caller running above the handler (e.g. an HTTP middleware that wants to react to "a write happened during this request"). The *atomic.Bool sidecar bridges that gap — the middleware keeps the pointer, calls the next handler with the derived ctx, and inspects the bool after the handler returns.

The observer mechanism is intentionally independent from WithReadPromotion: it does not care which transactor the write went through, nor whether the caller participates in ro/rw routing. Any successful commit of a transactor with Transactor.IsReadOnly == false trips it.

Callers that never attach an observer pay only a single ctx lookup per commit (see [noteWriteObserved]), so non-HTTP consumers (Temporal activities, bootstrap, tests) are unaffected.

Re-calling WithWriteObserver on an already-observed ctx attaches a fresh observer that shadows the previous one for descendants of the new ctx; the previously-returned pointer keeps observing only what is reachable through the older ctx.