Plugins: Bump SystemJS to 6.14.2 (#70068)

* chore(plugins): bump systemjs to latest version

* refactor(plugins): switch runtime over to use latest systemjs, add typings

* refactor(plugins): use latest systemjs APIs for runtime dependency resolution

* refactor(plugins): return valid urls from backend for latest systemjs import to work

* revert(plugins): remove cfg from assetpath in favour of relative paths

* fix(plugins): useDefault for systemjs deps to solve undefined errors

* feat(plugins): add basic support for loading plugins via CDN

* fix(plugins): load nested plugins with latest systemjs

* feat(plugins): add back ability to transform plugin src for cdns

* feat(plugins): get caching for module.js working, clean up

* refactor(plugin_loader): create buildImportMap fn and more clean up

* refactor(angularapp): use buildImportMap for dependencies and clean up

* test(plugin_loader): fix failing test due to systemjs update

* test(jest): mock systemjs amd extra in tests to prevent it breaking tests

* chore(plugins): remove systemjs module-types extra, already included with system

* fix(plugins): update key for invalidating cached plugins

* fix: move systemjs amd define to another global so monaco can load

* refactor(plugins): clean up cache buster and tests

* chore(plugins): remove debug

* refactor(plugins): move systemjs define to keep global cleaner

* fix(plugins): set useDefault so system modules lodash references dont fail

* feat(plugins): hook systemjs onload so stylesheets are applied to the dom

* refactor(plugins): wrap amd formatted plugins in iife to prevent define collision

* feat(plugins): support system module format for legacy plugins

* test(plugincachebuster): update tests to match latest implementation

* test(plugins-loader): fix up tests post module property change

* fix test

* Update pkg/plugins/manager/loader/assetpath/assetpath.go

Co-authored-by: Will Browne <wbrowne@users.noreply.github.com>

* chore(plugin_loader): remove stray import from merge conflict

* Revert "Update pkg/plugins/manager/loader/assetpath/assetpath.go"

This reverts commit 0df57d1cf20f49c22c93369001c70aae46a97c42.

* fix(plugin_loader): set use default for shared plugin dependencies

* refactor(plugins): use leading slash for Module and BaseUrl

* fix(plugins): fix resolve appending extension to cache query param

* refactor(plugins): align baseurl and module paths

* refactor(plugins): update builtInPlugins keys to match naming convention

* refactor(plugins): minor loader clean up, fix up types

* test(plugins): fix failing tests

* refactor(plugins): rename cache buster systemjs plugin to cache

* refactor(plugins): separate plugin_loader into smaller files

* chore(plugins): clean up plugin_loader types

* chore(plugin_sandbox): fix typescript error

* chore(npm): remove unplug debug and pin systemjs to 6.14.1

* refactor(plugins-cdn): update loaders to use absolute module url from backend

* fix(plugins): escape period in systemjs  module regex

* chore(plugins): delete redundant systemjs plugins

* refactor(plugin_loader): move hooks into own file, add types

* test(plugins): add tests for systemjs loader hooks

* chore(plugins): rename systemjshooks file

* chore(plugins): remove redundant systemjs cdn backend code

* fix(plugins): handle loading with config.appSubUrl

* chore(plugins): delete redundant plugin-cdn angular code

* test(plugins): fix failing systemjs test missing pluginsCDNBaseUrl

* refactor(plugins): backend provides base and module properties with AppSubUrl

* fix(plugins): consider AppSubUrl for plugin logos

* fix(plugins): use isHostedOnCDN util when checking for cdn hosted plugins

* add new appSubURL field to config

* refactor relative URL func

* fix path for core app

* refactor asset path input

* fix(plugins): catch errors in loadPluginCss

* feat(plugins-cdn): selectively transform sourceMapURL

* re-add deleted test case

* chore(plugins): bump to latest systemjs@6.14.2

* feat(plugins): add systemjs-cjs-extra for loading commonjs plugins

---------

Co-authored-by: Will Browne <will.browne@grafana.com>
Co-authored-by: Will Browne <wbrowne@users.noreply.github.com>
This commit is contained in:
Jack Westbrook
2023-08-31 15:45:44 +02:00
committed by GitHub
parent b2f7476bb4
commit 62821c69b3
49 changed files with 1155 additions and 887 deletions

View File

@ -17,47 +17,57 @@ import (
// on the plugins CDN, and it will switch to the correct implementation depending on the plugin and the config.
type Service struct {
cdn *pluginscdn.Service
cfg *config.Cfg
}
func ProvideService(cdn *pluginscdn.Service) *Service {
return &Service{cdn: cdn}
func ProvideService(cfg *config.Cfg, cdn *pluginscdn.Service) *Service {
return &Service{cfg: cfg, cdn: cdn}
}
type PluginInfo struct {
pluginJSON plugins.JSONData
class plugins.Class
dir string
}
func NewPluginInfo(pluginJSON plugins.JSONData, class plugins.Class, fs plugins.FS) PluginInfo {
return PluginInfo{
pluginJSON: pluginJSON,
class: class,
dir: fs.Base(),
}
}
func DefaultService(cfg *config.Cfg) *Service {
return &Service{cdn: pluginscdn.ProvideService(cfg)}
return &Service{cfg: cfg, cdn: pluginscdn.ProvideService(cfg)}
}
// Base returns the base path for the specified plugin.
func (s *Service) Base(pluginJSON plugins.JSONData, class plugins.Class, pluginDir string) (string, error) {
if class == plugins.ClassCore {
return path.Join("public/app/plugins", string(pluginJSON.Type), filepath.Base(pluginDir)), nil
func (s *Service) Base(n PluginInfo) (string, error) {
if n.class == plugins.ClassCore {
return path.Join("/", s.cfg.GrafanaAppSubURL, "/public/app/plugins", string(n.pluginJSON.Type), filepath.Base(n.dir)), nil
}
if s.cdn.PluginSupported(pluginJSON.ID) {
return s.cdn.SystemJSAssetPath(pluginJSON.ID, pluginJSON.Info.Version, "")
if s.cdn.PluginSupported(n.pluginJSON.ID) {
return s.cdn.AssetURL(n.pluginJSON.ID, n.pluginJSON.Info.Version, "")
}
return path.Join("public/plugins", pluginJSON.ID), nil
return path.Join("/", s.cfg.GrafanaAppSubURL, "/public/plugins", n.pluginJSON.ID), nil
}
// Module returns the module.js path for the specified plugin.
func (s *Service) Module(pluginJSON plugins.JSONData, class plugins.Class, pluginDir string) (string, error) {
if class == plugins.ClassCore {
return path.Join("app/plugins", string(pluginJSON.Type), filepath.Base(pluginDir), "module"), nil
func (s *Service) Module(n PluginInfo) (string, error) {
if n.class == plugins.ClassCore {
return path.Join("core:plugin", filepath.Base(n.dir)), nil
}
if s.cdn.PluginSupported(pluginJSON.ID) {
return s.cdn.SystemJSAssetPath(pluginJSON.ID, pluginJSON.Info.Version, "module")
if s.cdn.PluginSupported(n.pluginJSON.ID) {
return s.cdn.AssetURL(n.pluginJSON.ID, n.pluginJSON.Info.Version, "module.js")
}
return path.Join("plugins", pluginJSON.ID, "module"), nil
return path.Join("/", s.cfg.GrafanaAppSubURL, "/public/plugins", n.pluginJSON.ID, "module.js"), nil
}
// RelativeURL returns the relative URL for an arbitrary plugin asset.
// If pathStr is an empty string, defaultStr is returned.
func (s *Service) RelativeURL(p *plugins.Plugin, pathStr, defaultStr string) (string, error) {
if pathStr == "" {
return defaultStr, nil
}
if s.cdn.PluginSupported(p.ID) {
// CDN
return s.cdn.NewCDNURLConstructor(p.ID, p.Info.Version).StringPath(pathStr)
func (s *Service) RelativeURL(n PluginInfo, pathStr string) (string, error) {
if s.cdn.PluginSupported(n.pluginJSON.ID) {
return s.cdn.NewCDNURLConstructor(n.pluginJSON.ID, n.pluginJSON.Info.Version).StringPath(pathStr)
}
// Local
u, err := url.Parse(pathStr)
@ -67,9 +77,20 @@ func (s *Service) RelativeURL(p *plugins.Plugin, pathStr, defaultStr string) (st
if u.IsAbs() {
return pathStr, nil
}
// is set as default or has already been prefixed with base path
if pathStr == defaultStr || strings.HasPrefix(pathStr, p.BaseURL) {
baseURL, err := s.Base(n)
if err != nil {
return "", err
}
// has already been prefixed with base path
if strings.HasPrefix(pathStr, baseURL) {
return pathStr, nil
}
return path.Join(p.BaseURL, pathStr), nil
return path.Join(baseURL, pathStr), nil
}
// DefaultLogoPath returns the default logo path for the specified plugin type.
func (s *Service) DefaultLogoPath(pluginType plugins.Type) string {
return path.Join("/", s.cfg.GrafanaAppSubURL, fmt.Sprintf("/public/img/icn-%s.svg", string(pluginType)))
}

View File

@ -1,17 +1,20 @@
package assetpath
import (
"net/url"
"strings"
"testing"
"github.com/stretchr/testify/require"
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/plugins/config"
"github.com/grafana/grafana/pkg/plugins/manager/fakes"
"github.com/grafana/grafana/pkg/plugins/pluginscdn"
"github.com/stretchr/testify/require"
)
func extPath(pluginID string) string {
return "/grafana/data/plugins/" + pluginID
func extPath(pluginID string) *fakes.FakePluginFiles {
return fakes.NewFakePluginFiles(pluginID)
}
func TestService(t *testing.T) {
@ -33,15 +36,16 @@ func TestService(t *testing.T) {
},
} {
t.Run(tc.name, func(t *testing.T) {
svc := ProvideService(pluginscdn.ProvideService(&config.Cfg{
cfg := &config.Cfg{
PluginsCDNURLTemplate: tc.cdnBaseURL,
PluginSettings: map[string]map[string]string{
"one": {"cdn": "true"},
"two": {},
},
}))
}
svc := ProvideService(cfg, pluginscdn.ProvideService(cfg))
const tableOldPath = "/grafana/public/app/plugins/panel/table-old"
tableOldFS := fakes.NewFakePluginFiles("/grafana/public/app/plugins/panel/table-old")
jsonData := map[string]plugins.JSONData{
"table-old": {ID: "table-old", Info: plugins.Info{Version: "1.0.0"}},
@ -56,60 +60,110 @@ func TestService(t *testing.T) {
})
t.Run("Base", func(t *testing.T) {
base, err := svc.Base(jsonData["one"], plugins.ClassExternal, extPath("one"))
base, err := svc.Base(NewPluginInfo(jsonData["one"], plugins.ClassExternal, extPath("one")))
require.NoError(t, err)
require.Equal(t, "plugin-cdn/one/1.0.0/public/plugins/one", base)
base, err = svc.Base(jsonData["two"], plugins.ClassExternal, extPath("two"))
u, err := url.JoinPath(tc.cdnBaseURL, "/one/1.0.0/public/plugins/one")
require.NoError(t, err)
require.Equal(t, "public/plugins/two", base)
require.Equal(t, u, base)
base, err = svc.Base(jsonData["table-old"], plugins.ClassCore, tableOldPath)
base, err = svc.Base(NewPluginInfo(jsonData["two"], plugins.ClassExternal, extPath("two")))
require.NoError(t, err)
require.Equal(t, "public/app/plugins/table-old", base)
require.Equal(t, "/public/plugins/two", base)
base, err = svc.Base(NewPluginInfo(jsonData["table-old"], plugins.ClassCore, tableOldFS))
require.NoError(t, err)
require.Equal(t, "/public/app/plugins/table-old", base)
})
t.Run("Module", func(t *testing.T) {
module, err := svc.Module(jsonData["one"], plugins.ClassExternal, extPath("one"))
module, err := svc.Module(NewPluginInfo(jsonData["one"], plugins.ClassExternal, extPath("one")))
require.NoError(t, err)
require.Equal(t, "plugin-cdn/one/1.0.0/public/plugins/one/module", module)
module, err = svc.Module(jsonData["two"], plugins.ClassExternal, extPath("two"))
u, err := url.JoinPath(tc.cdnBaseURL, "/one/1.0.0/public/plugins/one/module.js")
require.NoError(t, err)
require.Equal(t, "plugins/two/module", module)
require.Equal(t, u, module)
module, err = svc.Module(jsonData["table-old"], plugins.ClassCore, tableOldPath)
module, err = svc.Module(NewPluginInfo(jsonData["two"], plugins.ClassExternal, extPath("two")))
require.NoError(t, err)
require.Equal(t, "app/plugins/table-old/module", module)
require.Equal(t, "/public/plugins/two/module.js", module)
module, err = svc.Module(NewPluginInfo(jsonData["table-old"], plugins.ClassCore, tableOldFS))
require.NoError(t, err)
require.Equal(t, "core:plugin/table-old", module)
})
t.Run("RelativeURL", func(t *testing.T) {
pluginsMap := map[string]*plugins.Plugin{
"one": {
JSONData: plugins.JSONData{ID: "one", Info: plugins.Info{Version: "1.0.0"}},
BaseURL: "plugin-cdn/one/1.0.0/public/pluginsMap/one",
},
"two": {
JSONData: plugins.JSONData{ID: "two", Info: plugins.Info{Version: "2.0.0"}},
BaseURL: "public/pluginsMap/two",
},
}
u, err := svc.RelativeURL(pluginsMap["one"], "", "default")
require.NoError(t, err)
require.Equal(t, "default", u)
u, err = svc.RelativeURL(pluginsMap["one"], "path/to/file.txt", "default")
u, err := svc.RelativeURL(NewPluginInfo(pluginsMap["one"].JSONData, plugins.ClassExternal, extPath("one")), "")
require.NoError(t, err)
// given an empty path, base URL will be returned
baseURL, err := svc.Base(NewPluginInfo(pluginsMap["one"].JSONData, plugins.ClassExternal, extPath("one")))
require.NoError(t, err)
require.Equal(t, baseURL, u)
u, err = svc.RelativeURL(NewPluginInfo(pluginsMap["one"].JSONData, plugins.ClassExternal, extPath("one")), "path/to/file.txt")
require.NoError(t, err)
require.Equal(t, strings.TrimRight(tc.cdnBaseURL, "/")+"/one/1.0.0/public/plugins/one/path/to/file.txt", u)
u, err = svc.RelativeURL(pluginsMap["two"], "path/to/file.txt", "default")
u, err = svc.RelativeURL(NewPluginInfo(pluginsMap["two"].JSONData, plugins.ClassExternal, extPath("two")), "path/to/file.txt")
require.NoError(t, err)
require.Equal(t, "public/pluginsMap/two/path/to/file.txt", u)
require.Equal(t, "/public/plugins/two/path/to/file.txt", u)
u, err = svc.RelativeURL(pluginsMap["two"], "default", "default")
u, err = svc.RelativeURL(NewPluginInfo(pluginsMap["two"].JSONData, plugins.ClassExternal, extPath("two")), "default")
require.NoError(t, err)
require.Equal(t, "default", u)
require.Equal(t, "/public/plugins/two/default", u)
})
})
}
t.Run("With App Sub URL", func(t *testing.T) {
for _, tc := range []struct {
appSubURL string
}{
{
appSubURL: "grafana",
},
{
appSubURL: "/grafana",
},
{
appSubURL: "grafana/",
},
{
appSubURL: "/grafana/",
},
} {
cfg := &config.Cfg{GrafanaAppSubURL: tc.appSubURL}
svc := ProvideService(cfg, pluginscdn.ProvideService(cfg))
dir := "/plugins/test-datasource"
p := plugins.JSONData{ID: "test-datasource"}
fs := fakes.NewFakePluginFiles(dir)
base, err := svc.Base(NewPluginInfo(p, plugins.ClassExternal, fs))
require.NoError(t, err)
require.Equal(t, "/grafana/public/plugins/test-datasource", base)
mod, err := svc.Module(NewPluginInfo(p, plugins.ClassExternal, fs))
require.NoError(t, err)
require.Equal(t, "/grafana/public/plugins/test-datasource/module.js", mod)
base, err = svc.Base(NewPluginInfo(p, plugins.ClassCore, fs))
require.NoError(t, err)
require.Equal(t, "/grafana/public/app/plugins/test-datasource", base)
mod, err = svc.Module(NewPluginInfo(p, plugins.ClassCore, fs))
require.NoError(t, err)
require.Equal(t, "core:plugin/test-datasource", mod)
}
})
}