Method moduleSourceWithSourceSubpath

core/schema/modulesource.go:1177–1220

(
	ctx context.Context,
	src *core.ModuleSource,
	args struct {
		Path string
	},
)

}

func (s *moduleSourceSchema) moduleSourceWithSourceSubpath(
	ctx context.Context,
	src *core.ModuleSource,
	args struct {
		Path string
	},
) (*core.ModuleSource, error) {
	src = src.Clone()
	src.SourceSubpath = filepath.Join(src.SourceRootSubpath, args.Path)

	contextRootPath := "/"
	if src.Kind == core.ModuleSourceKindLocal {
		contextRootPath = src.Local.ContextDirectoryPath
	}

	relPath, err := pathutil.LexicalRelativePath(
		filepath.Join(contextRootPath, src.SourceRootSubpath),
		filepath.Join(contextRootPath, src.SourceSubpath),
	)
	if err != nil {
		return nil, fmt.Errorf("failed to get relative path from source root to source subpath: %w", err)
	}
	if !filepath.IsLocal(relPath) {
		return nil, fmt.Errorf("local module source subpath %q escapes source root %q", relPath, src.SourceRootSubpath)
	}

	// reload context since the subpath impacts what we implicitly include in the load
	err = s.loadModuleSourceContext(ctx, src)
	switch {
	case err == nil:
	case codes.NotFound == status.Code(err) && src.Kind == core.ModuleSourceKindLocal:
		// corner case: dagger init can be called on a context dir that doesn't exist yet
		// (e.g. called outside a .git context and the source root dir doesn't exist because
		// it's expected to be created when exporting the generated context dir)
		// we tolerate a not found error in this case
	default:
		return nil, fmt.Errorf("failed to reload module source context: %w", err)
	}

	if err := src.LoadUserDefaults(ctx); err != nil {
		return nil, fmt.Errorf("load user defaults: %w", err)
	}
	return src, nil
}

func (s *moduleSourceSchema) moduleSourceAsString(
	ctx context.Context,