Method UserDefault

core/modfunc.go:553–612

Lookup a user default for this function

(ctx context.Context, argName string)

// Lookup a user default for this function
func (fn *ModuleFunction) UserDefault(ctx context.Context, argName string) (*UserDefault, bool, error) {
	// Lookup the argument typedef
	arg, ok := fn.metadata.LookupArg(argName)
	if !ok {
		return nil, false, fmt.Errorf("lookup default: function %q has no argument %q", fn.metadata.Name, argName)
	}

	isConstructor := fn.metadata.Name == ""

	// TODO(workspace-env-expansion): Implement ${VAR} expansion for workspace config string values.
	//
	// Spec:
	// - $VAR and ${VAR} in string config values should resolve to system environment variables
	// - NO cascading: $FOO always means the system env var FOO, never another config key
	// - Resolution should go through the Workspace type (gateway for client context access)
	// - The Workspace type should expose a method for resolving system env vars,
	//   which can later be gated by interactive prompts, allow/deny policies, value injection
	// - Consider docker-compose's variable substitution spec as reference for syntax
	// - For now, string values pass through as-is (no expansion)

	// PATH A: Workspace config (constructor only, no EnvFile)
	if fn.mod.Self().WorkspaceConfig != nil && isConstructor {
		val, ok := lookupConfigCaseInsensitive(fn.mod.Self().WorkspaceConfig, arg.Self().OriginalName, arg.Self().Name)
		if ok {
			return fn.newUserDefault(arg.Self(), configValueToString(val)), true, nil
		}
		// Not in workspace config — only fall through to .env if enabled
		if !fn.mod.Self().DefaultsFromDotEnv {
			return nil, false, nil
		}
	}

	// PATH B: existing .env pipeline (completely unchanged)
	// We need access to the main client's context for resolving system env variables
	// (otherwise we may resolve them in the module container's context)
	// so we upgrade the context to the main client.
	query, err := CurrentQuery(ctx)
	if err != nil {
		return nil, false, fmt.Errorf("get current query: %w", err)
	}
	mainClient, err := query.NonModuleParentClientMetadata(ctx)
	if err != nil {
		return nil, false, fmt.Errorf("access main client: %w", err)
	}
	mainCtx := engine.ContextWithClientMetadata(ctx, mainClient)
	// Get all defaults for this function
	// FIXME: we shouldn't need the main client context here (we don't need to evaluate env values yet)
	defaults, err := fn.UserDefaults(mainCtx)
	if err != nil {
		return nil, false, fmt.Errorf("lookup defaults for function %q: %w", fn.metadata.Name, err)
	}
	userInput, ok, err := defaults.LookupCaseInsensitive(mainCtx, arg.Self().Name)
	if err != nil {
		return nil, false, err
	}
	if !ok {
		return nil, false, nil
	}