Function inspectModule

cmd/dagger/module_inspect.go:192–289

(ctx context.Context, dag *dagger.Client, source *dagger.ModuleSource)

var loadTypeDefsQuery string

func inspectModule(ctx context.Context, dag *dagger.Client, source *dagger.ModuleSource) (rdef *moduleDef, rerr error) {
	ctx, span := Tracer().Start(ctx, "inspecting module metadata", telemetry.Encapsulate())
	defer telemetry.EndWithCause(span, &rerr)

	// NB: All we need most of the time is the name of the dependencies.
	// We need the descriptions when listing the dependencies, and the source
	// ref if we need to load a specific dependency. However getting the refs
	// and descriptions here, at module load, doesn't add much overhead and
	// makes it easier (and faster) later.

	var res struct {
		Source struct {
			Kind              dagger.ModuleSourceKind
			Digest            string
			AsString          string
			SourceRootSubpath string
			Commit            string
			Version           string
			HTMLRepoURL       string
			Module            struct {
				Name         string
				Description  string
				Dependencies []struct {
					Name        string
					Description string
					Source      struct {
						ID       dagger.ID
						AsString string
						Digest   string
					}
				}
			}
		}
	}

	id, err := source.ID(ctx)
	if err != nil {
		return nil, err
	}

	err = dag.Do(ctx, &dagger.Request{
		Query: loadModConfQuery,
		Variables: map[string]any{
			"source": id,
		},
	}, &dagger.Response{
		Data: &res,
	})
	if err != nil {
		return nil, fmt.Errorf("query module metadata: %w", err)
	}

	deps := make([]*moduleDef, 0, len(res.Source.Module.Dependencies))
	for _, dep := range res.Source.Module.Dependencies {
		deps = append(deps, &moduleDef{
			Name:         dep.Name,
			Description:  dep.Description,
			SourceRoot:   dep.Source.AsString,