Function NodeFuncWithDynamicInputs

dagql/objects.go:769–847

NodeFuncWithDynamicInputs is like NodeFunc but lets a resolver customize request/cache behavior for each call (for example argument rewrites, TTL, do-not-cache, or concurrency key).

(
	name string,
	fn NodeFuncHandler[T, A, R],
	cacheFn DynamicInputFunc[T, A],
)

// request/cache behavior for each call (for example argument rewrites, TTL,
// do-not-cache, or concurrency key).
func NodeFuncWithDynamicInputs[T Typed, A any, R any](
	name string,
	fn NodeFuncHandler[T, A, R],
	cacheFn DynamicInputFunc[T, A],
) Field[T] {
	var zeroArgs A
	inputs, argsErr := InputSpecsForType(zeroArgs, true)
	if argsErr != nil {
		var zeroSelf T
		slog.Error("failed to parse args", "type", zeroSelf.Type(), "field", name, "error", argsErr)
	}

	spec := &FieldSpec{
		Name: name,
		Args: inputs,
	}

	var zeroRet R
	var returnTypeError error
	if res, ok := any(zeroRet).(AnyResult); ok {
		spec.Type = res.Unwrap()
	} else {
		spec.Type, returnTypeError = builtinOrTyped(zeroRet)
	}

	field := Field[T]{
		Spec: spec,
		Func: func(ctx context.Context, self ObjectResult[T], argVals map[string]Input, view call.View) (AnyResult, error) {
			// these errors are deferred until runtime, since it's better (at least
			// more testable) than panicking
			if argsErr != nil {
				return nil, argsErr
			}
			if returnTypeError != nil {
				return nil, returnTypeError
			}

			var args A
			if err := spec.Args.Decode(argVals, &args, view); err != nil {
				return nil, err
			}
			ret, err := fn(ctx, self, args)
			if err != nil {
				return nil, err
			}

			if res, ok := any(ret).(AnyResult); ok {
				return res, nil
			}
			res, err := builtinOrTyped(ret)
			if err != nil {
				return nil, fmt.Errorf("expected %T to be a Typed value, got %T: %w", ret, ret, err)
			}

			return NewResultForCurrentCall(ctx, res)
		},
	}