Expose some data from feature for commands

internal/features/modules/modules_feature.go

@@ -12,6 +12,7 @@ import (
 	"path/filepath"
 
 	"github.com/hashicorp/go-multierror"
+	"github.com/hashicorp/go-version"
 	"github.com/hashicorp/hcl-lang/decoder"
 	"github.com/hashicorp/hcl-lang/lang"
 	"github.com/hashicorp/terraform-ls/internal/document"
@@ -413,3 +414,25 @@ func (f *ModulesFeature) Paths(ctx context.Context) []lang.Path {
 
 	return paths
 }
+
+func (f *ModulesFeature) DeclaredModuleCalls(modPath string) (map[string]tfmod.DeclaredModuleCall, error) {
+	return f.store.DeclaredModuleCalls(modPath)
+}
+
+func (f *ModulesFeature) ProviderRequirements(modPath string) (tfmod.ProviderRequirements, error) {
+	mod, err := f.store.ModuleRecordByPath(modPath)
+	if err != nil {
+		return nil, err
+	}
+
+	return mod.Meta.ProviderRequirements, nil
+}
+
+func (f *ModulesFeature) CoreRequirements(modPath string) (version.Constraints, error) {
+	mod, err := f.store.ModuleRecordByPath(modPath)
+	if err != nil {
+		return nil, err
+	}
+
+	return mod.Meta.CoreRequirements, nil
+}

internal/features/rootmodules/root_modules_feature.go

@@ -19,6 +19,7 @@ import (
 	globalState "github.com/hashicorp/terraform-ls/internal/state"
 	"github.com/hashicorp/terraform-ls/internal/terraform/exec"
 	op "github.com/hashicorp/terraform-ls/internal/terraform/module/operation"
+	tfaddr "github.com/hashicorp/terraform-registry-address"
 	tfmod "github.com/hashicorp/terraform-schema/module"
 )
 
@@ -142,6 +143,19 @@ func (f *RootModulesFeature) TerraformVersion(modPath string) *version.Version {
 	return version.TerraformVersion
 }
 
+func (f *RootModulesFeature) InstalledProviders(modPath string) (map[tfaddr.Provider]*version.Version, error) {
+	record, err := f.store.RootRecordByPath(modPath)
+	if err != nil {
+		return nil, err
+	}
+
+	return record.InstalledProviders, nil
+}
+
+func (f *RootModulesFeature) CallersOfModule(modPath string) ([]string, error) {
+	return f.store.CallersOfModule(modPath)
+}
+
 func (f *RootModulesFeature) ModuleManifestChanged(ctx context.Context, modHandle document.DirHandle) (job.IDs, error) {
 	ids := make(job.IDs, 0)
 

internal/features/rootmodules/state/root_record.go

@@ -375,22 +375,22 @@ func (s *RootStore) UpdateTerraformAndProviderVersions(modPath string, tfVer *ve
 	return nil
 }
 
-func (s *RootStore) CallersOfModule(modPath string) ([]*RootRecord, error) {
+func (s *RootStore) CallersOfModule(modPath string) ([]string, error) {
 	txn := s.db.Txn(false)
 	it, err := txn.Get(s.tableName, "id")
 	if err != nil {
 		return nil, err
 	}
 
-	callers := make([]*RootRecord, 0)
+	callers := make([]string, 0)
 	for item := it.Next(); item != nil; item = it.Next() {
 		record := item.(*RootRecord)
 
 		if record.ModManifest == nil {
 			continue
 		}
 		if record.ModManifest.ContainsLocalModule(modPath) {
-			callers = append(callers, record)
+			callers = append(callers, record.path)
 		}
 	}
 

internal/langserver/handlers/command/handler.go

@@ -6,10 +6,26 @@ package command
 import (
 	"log"
 
+	"github.com/hashicorp/go-version"
 	"github.com/hashicorp/terraform-ls/internal/state"
+	tfaddr "github.com/hashicorp/terraform-registry-address"
+	tfmod "github.com/hashicorp/terraform-schema/module"
 )
 
+type FeatureReader interface {
+	// ModulesFeature
+	DeclaredModuleCalls(modPath string) (map[string]tfmod.DeclaredModuleCall, error)
+	ProviderRequirements(modPath string) (tfmod.ProviderRequirements, error)
+	CoreRequirements(modPath string) (version.Constraints, error)
+	// RootModulesFeature
+	CallersOfModule(modPath string) ([]string, error)
+	InstalledModuleCalls(modPath string) (map[string]tfmod.InstalledModuleCall, error)
+	InstalledProviders(modPath string) (map[tfaddr.Provider]*version.Version, error)
+	TerraformVersion(modPath string) *version.Version
+}
+
 type CmdHandler struct {
-	StateStore *state.StateStore
-	Logger     *log.Logger
+	StateStore    *state.StateStore
+	Logger        *log.Logger
+	FeatureReader FeatureReader
 }

internal/langserver/handlers/command/init.go

@@ -12,7 +12,6 @@ import (
 	"github.com/hashicorp/terraform-ls/internal/langserver/cmd"
 	"github.com/hashicorp/terraform-ls/internal/langserver/errors"
 	"github.com/hashicorp/terraform-ls/internal/langserver/progress"
-	"github.com/hashicorp/terraform-ls/internal/state"
 	"github.com/hashicorp/terraform-ls/internal/terraform/module"
 	"github.com/hashicorp/terraform-ls/internal/uri"
 )
@@ -28,24 +27,7 @@ func (h *CmdHandler) TerraformInitHandler(ctx context.Context, args cmd.CommandA
 	}
 
 	dirHandle := document.DirHandleFromURI(dirUri)
-
-	mod, err := h.StateStore.Roots.RootRecordByPath(dirHandle.Path())
-	if err != nil {
-		if state.IsRecordNotFound(err) {
-			err = h.StateStore.Roots.Add(dirHandle.Path())
-			if err != nil {
-				return nil, err
-			}
-			mod, err = h.StateStore.Roots.RootRecordByPath(dirHandle.Path())
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			return nil, err
-		}
-	}
-
-	tfExec, err := module.TerraformExecutorForModule(ctx, mod.Path())
+	tfExec, err := module.TerraformExecutorForModule(ctx, dirHandle.Path())
 	if err != nil {
 		return nil, errors.EnrichTfExecError(err)
 	}

internal/langserver/handlers/command/module_callers.go

@@ -39,15 +39,15 @@ func (h *CmdHandler) ModuleCallersHandler(ctx context.Context, args cmd.CommandA
 		return nil, err
 	}
 
-	modCallers, err := h.StateStore.Roots.CallersOfModule(modPath)
+	modCallers, err := h.FeatureReader.CallersOfModule(modPath)
 	if err != nil {
 		return nil, err
 	}
 
 	callers := make([]moduleCaller, 0)
 	for _, caller := range modCallers {
 		callers = append(callers, moduleCaller{
-			URI: uri.FromPath(caller.Path()),
+			URI: uri.FromPath(caller),
 		})
 	}
 	sort.SliceStable(callers, func(i, j int) bool {

internal/langserver/handlers/command/module_calls.go

@@ -62,16 +62,16 @@ func (h *CmdHandler) ModuleCallsHandler(ctx context.Context, args cmd.CommandArg
 		return response, err
 	}
 
-	// declared, err := h.StateStore.Modules.DeclaredModuleCalls(modPath)
-	// if err != nil {
-	// 	return response, err
-	// }
-	installed, err := h.StateStore.Roots.InstalledModuleCalls(modPath)
+	declared, err := h.FeatureReader.DeclaredModuleCalls(modPath)
+	if err != nil {
+		return response, err
+	}
+	installed, err := h.FeatureReader.InstalledModuleCalls(modPath)
 	if err != nil {
 		return response, err
 	}
 	moduleCalls := tfmod.ModuleCalls{
-		// Declared:  declared,
+		Declared:  declared,
 		Installed: installed,
 	}
 

internal/langserver/handlers/command/module_providers.go

@@ -43,32 +43,34 @@ func (h *CmdHandler) ModuleProvidersHandler(ctx context.Context, args cmd.Comman
 		return response, fmt.Errorf("URI %q is not valid", modUri)
 	}
 
-	// modPath, err := uri.PathFromURI(modUri)
-	// if err != nil {
-	// 	return response, err
-	// }
-
-	// mod, _ := h.StateStore.Modules.ModuleByPath(modPath)
-	// if mod == nil {
-	// 	return response, nil
-	// }
-
-	// for provider, version := range mod.Meta.ProviderRequirements {
-	// 	docsLink, err := getProviderDocumentationLink(ctx, provider)
-	// 	if err != nil {
-	// 		return response, err
-	// 	}
-	// 	response.ProviderRequirements[provider.String()] = providerRequirement{
-	// 		DisplayName:       provider.ForDisplay(),
-	// 		VersionConstraint: version.String(),
-	// 		DocsLink:          docsLink,
-	// 	}
-	// }
-
-	// TODO!
-	// for provider, version := range mod.InstalledProviders {
-	// 	response.InstalledProviders[provider.String()] = version.String()
-	// }
+	modPath, err := uri.PathFromURI(modUri)
+	if err != nil {
+		return response, err
+	}
+
+	providerRequirements, err := h.FeatureReader.ProviderRequirements(modPath)
+	if err != nil {
+		return response, err
+	}
+	for provider, version := range providerRequirements {
+		docsLink, err := getProviderDocumentationLink(ctx, provider)
+		if err != nil {
+			return response, err
+		}
+		response.ProviderRequirements[provider.String()] = providerRequirement{
+			DisplayName:       provider.ForDisplay(),
+			VersionConstraint: version.String(),
+			DocsLink:          docsLink,
+		}
+	}
+
+	installedProviders, err := h.FeatureReader.InstalledProviders(modPath)
+	if err != nil {
+		return response, err
+	}
+	for provider, version := range installedProviders {
+		response.InstalledProviders[provider.String()] = version.String()
+	}
 
 	return response, nil
 }

internal/langserver/handlers/command/terraform.go

@@ -46,18 +46,20 @@ func (h *CmdHandler) TerraformVersionRequestHandler(ctx context.Context, args cm
 		return response, err
 	}
 
-	mod, _ := h.StateStore.Roots.RootRecordByPath(modPath)
-	if mod == nil {
-		return response, nil
+	progress.Report(ctx, "Recording terraform version info ...")
+
+	terraformVersion := h.FeatureReader.TerraformVersion(modPath)
+	if terraformVersion != nil {
+		response.DiscoveredVersion = terraformVersion.String()
 	}
 
-	progress.Report(ctx, "Recording terraform version info ...")
-	if mod.TerraformVersion != nil {
-		response.DiscoveredVersion = mod.TerraformVersion.String()
+	coreRequirements, err := h.FeatureReader.CoreRequirements(modPath)
+	if err != nil {
+		return response, err
+	}
+	if coreRequirements != nil {
+		response.RequiredVersion = coreRequirements.String()
 	}
-	// if mod.Meta.CoreRequirements != nil {
-	// 	response.RequiredVersion = mod.Meta.CoreRequirements.String()
-	// }
 
 	progress.Report(ctx, "Sending response ...")