Function objFun

core/object.go:1399–1452

objFun creates a dagql.Field for a function defined on a module object type. This is used during the GraphQL schema installation process to convert user-defined functions in module object types into callable GraphQL fields. Flow: 1. Called from ModuleObject.functions() during ModuleObject.Install()

(ctx context.Context, mod dagql.ObjectResult[*Module], objDef *ObjectTypeDef, fun *Function, dag *dagql.Server)

// The resulting field enables users to call their custom functions as GraphQL
// fields on their object types, with proper argument handling and caching.
func objFun(ctx context.Context, mod dagql.ObjectResult[*Module], objDef *ObjectTypeDef, fun *Function, dag *dagql.Server) (dagql.Field[*ModuleObject], error) {
	var f dagql.Field[*ModuleObject]
	if mod.Self() == nil {
		return f, fmt.Errorf("install function %q without module result wrapper", fun.Name)
	}
	modFun, err := NewModFunction(
		ctx,
		mod,
		objDef,
		fun,
	)
	if err != nil {
		return f, fmt.Errorf("failed to create function %q: %w", fun.Name, err)
	}
	// Apply local user defaults to the function's arguments, so that they show
	// up in installed typedefs (for introspection)
	if err := modFun.mergeUserDefaultsTypeDefs(ctx); err != nil {
		return f, fmt.Errorf("failed to merge user defaults for %q: %w", fun.Name, err)
	}
	spec, err := modFun.metadata.FieldSpec(ctx, NewUserMod(mod))
	if err != nil {
		return f, fmt.Errorf("failed to get field spec: %w", err)
	}
	moduleID, err := NewUserMod(mod).ResultCallModule(ctx)
	if err != nil {
		return f, fmt.Errorf("failed to resolve module identity for function %q: %w", fun.Name, err)
	}
	spec.Module = moduleID
	spec.GetDynamicInput = modFun.DynamicInputsForCall
	spec.ImplicitInputs = append(spec.ImplicitInputs, modFun.cacheImplicitInputs()...)

	return dagql.Field[*ModuleObject]{
		Spec: &spec,
		Func: func(ctx context.Context, obj dagql.ObjectResult[*ModuleObject], args map[string]dagql.Input, view call.View) (dagql.AnyResult, error) {
			opts := &CallOpts{
				ParentTyped:    obj,
				ParentFields:   obj.Self().Fields,
				SkipSelfSchema: false,
				Server:         dag,
			}
			for name, val := range args {
				opts.Inputs = append(opts.Inputs, CallInput{
					Name:  name,
					Value: val,
				})
			}
			// NB: ensure deterministic order
			sort.Slice(opts.Inputs, func(i, j int) bool {
				return opts.Inputs[i].Name < opts.Inputs[j].Name
			})
			return modFun.Call(ctx, opts)
		},
	}, nil
}

type CallableField struct {
	Module *Module