Method loadTypeDefs

cmd/dagger/module_inspect.go:299–406

loadTypeDefs loads the objects defined by the given module in an easier to use data structure.

(ctx context.Context, dag *dagger.Client, opts ...loadTypeDefsOpts)

// loadTypeDefs loads the objects defined by the given module in an easier to use data structure.
func (m *moduleDef) loadTypeDefs(ctx context.Context, dag *dagger.Client, opts ...loadTypeDefsOpts) (rerr error) {
	ctx, loadSpan := Tracer().Start(ctx, "loading type definitions", telemetry.Encapsulate())
	defer telemetry.EndWithCause(loadSpan, &rerr)

	var o loadTypeDefsOpts
	if len(opts) > 0 {
		o = opts[0]
	}

	var res struct {
		TypeDefs []*modTypeDef
	}

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

	m.MainObject = nil
	m.Objects = nil
	m.Interfaces = nil
	m.Enums = nil
	m.Inputs = nil
	m.typeDefsByName = make(map[string]*modTypeDef, len(res.TypeDefs))

	for _, typeDef := range res.TypeDefs {
		if typeDef == nil {
			return fmt.Errorf("currentTypeDefs returned nil TypeDef")
		}
		if typeDef.TypeName == "" {
			return fmt.Errorf("currentTypeDefs returned %s without canonical name", typeDef.Kind)
		}
		if _, found := m.typeDefsByName[typeDef.TypeName]; found {
			continue
		}
		m.typeDefsByName[typeDef.TypeName] = typeDef
		typeDef.owner = m
		switch typeDef.Kind {
		case dagger.TypeDefKindObjectKind:
			m.Objects = append(m.Objects, typeDef)
			if typeDef.AsObject != nil {
				typeDef.AsObject.owner = m
				typeDef.AsObject.typeDef = typeDef
			}
		case dagger.TypeDefKindInterfaceKind:
			m.Interfaces = append(m.Interfaces, typeDef)
			if typeDef.AsInterface != nil {
				typeDef.AsInterface.owner = m
				typeDef.AsInterface.typeDef = typeDef
			}
		case dagger.TypeDefKindEnumKind:
			m.Enums = append(m.Enums, typeDef)
		case dagger.TypeDefKindInputKind: