@perses-dev/plugin-system 0.54.0-beta.0 → 0.54.0-beta.2

package/dist/cjs/components/CalculationSelector/CalculationSelector.js

@@ -22,8 +22,8 @@ Object.defineProperty(exports, "CalculationSelector", {
 });
 const _jsxruntime = require("react/jsx-runtime");
 const _components = require("@perses-dev/components");
-const _core = require("@perses-dev/core");
-const CALC_OPTIONS = Object.entries(_core.CALCULATIONS_CONFIG).map(([id, config])=>{
+const _model = require("../../model");
+const CALC_OPTIONS = Object.entries(_model.CALCULATIONS_CONFIG).map(([id, config])=>{
     return {
         id: id,
         ...config
@@ -33,7 +33,7 @@ function CalculationSelector({ value, onChange }) {
     const handleCalculationChange = (_, newValue)=>{
         onChange(newValue.id);
     };
-    const calcConfig = _core.CALCULATIONS_CONFIG[value];
+    const calcConfig = _model.CALCULATIONS_CONFIG[value];
     return /*#__PURE__*/ (0, _jsxruntime.jsx)(_components.OptionsEditorControl, {
         label: "Calculation",
         control: /*#__PURE__*/ (0, _jsxruntime.jsx)(_components.SettingsAutocomplete, {

package/dist/cjs/components/DatasourceEditorForm/DatasourceEditorForm.js

@@ -27,13 +27,12 @@ const _components = require("@perses-dev/components");
 const _react = require("react");
 const _reacthookform = require("react-hook-form");
 const _context = require("../../context");
-const _utils = require("../../utils");
 const _PluginEditor = require("../PluginEditor");
 function DatasourceEditorForm(props) {
     const { initialDatasourceDefinition, action, isDraft, isReadonly, onActionChange, onSave, onClose, onDelete } = props;
     const [isDiscardDialogOpened, setDiscardDialogOpened] = (0, _react.useState)(false);
-    const titleAction = (0, _utils.getTitleAction)(action, isDraft);
-    const submitText = (0, _utils.getSubmitText)(action, isDraft);
+    const titleAction = (0, _components.getTitleAction)(action, isDraft);
+    const submitText = (0, _components.getSubmitText)(action, isDraft);
     const { datasourceEditorSchema } = (0, _context.useValidationSchemas)();
     const form = (0, _reacthookform.useForm)({
         resolver: (0, _zod.zodResolver)(datasourceEditorSchema),

package/dist/cjs/components/LegendOptionsEditor/LegendOptionsEditor.js

@@ -22,7 +22,6 @@ Object.defineProperty(exports, "LegendOptionsEditor", {
 });
 const _jsxruntime = require("react/jsx-runtime");
 const _material = require("@mui/material");
-const _core = require("@perses-dev/core");
 const _components = require("@perses-dev/components");
 const _react = require("react");
 const _model = require("../../model");
@@ -42,7 +41,7 @@ function LegendOptionsEditor({ value, onChange, showValuesEditor = true, calcula
     const handleLegendShowChange = (_, checked)=>{
         // legend is hidden when legend obj is undefined
         const legendValue = checked === true ? {
-            position: _core.DEFAULT_LEGEND.position
+            position: _components.DEFAULT_LEGEND.position
         } : undefined;
         onChange(legendValue);
     };
@@ -69,10 +68,10 @@ function LegendOptionsEditor({ value, onChange, showValuesEditor = true, calcula
         });
     };
     const isValidLegend = (0, _model.validateLegendSpec)(value);
-    const currentPosition = (0, _core.getLegendPosition)(value?.position);
+    const currentPosition = (0, _components.getLegendPosition)(value?.position);
     const legendPositionConfig = _model.LEGEND_POSITIONS_CONFIG[currentPosition];
-    const currentMode = (0, _core.getLegendMode)(value?.mode);
-    const currentSize = (0, _core.getLegendSize)(value?.size);
+    const currentMode = (0, _components.getLegendMode)(value?.mode);
+    const currentSize = (0, _components.getLegendSize)(value?.size);
     const legendSizeConfig = _model.LEGEND_SIZE_CONFIG[currentSize];
     const legendValuesConfig = (0, _react.useMemo)(()=>{
         const currentValues = value?.values;

package/dist/cjs/components/PluginRegistry/PluginRegistry.js

@@ -25,6 +25,7 @@ const _react = require("react");
 const _runtime = require("../../runtime");
 const _utils = require("../../utils");
 const _pluginindexes = require("./plugin-indexes");
+const _getPluginSearchHelper = require("./getPluginSearchHelper");
 function PluginRegistry(props) {
     const { pluginLoader: { getInstalledPlugins, importPluginModule }, children, defaultPluginKinds } = props;
     const getPluginIndexes = (0, _pluginindexes.usePluginIndexes)(getInstalledPlugins);
@@ -42,23 +43,18 @@ function PluginRegistry(props) {
         }
         return request;
     });
-    const getPlugin = (0, _react.useCallback)(async (kind, name)=>{
-        // Get the indexes of the installed plugins
+    const getPlugin = (0, _react.useCallback)(async (compoundKeyObj)=>{
         const pluginIndexes = await getPluginIndexes();
-        // Figure out what module the plugin is in by looking in the index
-        const typeAndKindKey = (0, _pluginindexes.getTypeAndKindKey)(kind, name);
-        const resource = pluginIndexes.pluginResourcesByNameAndKind.get(typeAndKindKey);
-        if (resource === undefined) {
-            throw new Error(`A ${name} plugin for kind '${kind}' is not installed`);
+        const { kind, name } = compoundKeyObj;
+        const candidateKeys = (0, _getPluginSearchHelper.resolvePluginKeys)(pluginIndexes.pluginResourcesByNameKindRegistryVersion.keys(), compoundKeyObj);
+        for (const resourceKey of candidateKeys){
+            const resource = pluginIndexes.pluginResourcesByNameKindRegistryVersion.get(resourceKey);
+            if (!resource) continue;
+            const pluginModule = await loadPluginModule(resource);
+            const plugin = pluginModule?.[resourceKey];
+            if (plugin) return plugin;
         }
-        // Treat the plugin module as a bunch of named exports that have plugins
-        const pluginModule = await loadPluginModule(resource);
-        // We currently assume that plugin modules will have named exports that match the kinds they handle
-        const plugin = pluginModule[name];
-        if (plugin === undefined) {
-            throw new Error(`The ${name} plugin for kind '${kind}' is missing from the ${resource.metadata.name} plugin module`);
-        }
-        return plugin;
+        throw new Error(`A ${name} plugin for kind '${kind}' is not installed`);
     }, [
         getPluginIndexes,
         loadPluginModule

package/dist/cjs/components/PluginRegistry/getPluginSearchHelper.js

@@ -0,0 +1,92 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolvePluginKeys", {
+    enumerable: true,
+    get: function() {
+        return resolvePluginKeys;
+    }
+});
+const _semver = require("semver");
+const _model = require("../../model");
+const PLUGIN_LOOKUP_PRECEDENCE_LOGIC = {
+    registryOverVersion: false
+};
+const resolvePluginKeys = (allKeys, query, precedenceLogic = PLUGIN_LOOKUP_PRECEDENCE_LOGIC)=>{
+    const { kind, name, version, registry } = query;
+    const candidates = [];
+    // Exact match first when version or registry is specified
+    if (version || registry) {
+        candidates.push((0, _model.getPluginModuleCompoundKey)({
+            kind,
+            name,
+            registry,
+            version
+        }));
+    }
+    const latestWithRegistry = {
+        key: '',
+        version: ''
+    };
+    const latestWithoutRegistry = {
+        key: '',
+        version: ''
+    };
+    const prefix = `${kind}:${name}:`;
+    for (const key of allKeys){
+        if (!key.startsWith(prefix)) continue;
+        const split = key.split(':');
+        if (split.length !== 4) {
+            console.warn(`An invalid Plugin Resource key detected during default plugin lookup: ${key}`);
+            continue;
+        }
+        const [, , reg, ver] = split;
+        if (!ver) {
+            console.warn(`An invalid Plugin Resource key detected during default plugin lookup: ${key}`);
+            continue;
+        }
+        if (reg) {
+            if (!latestWithRegistry.key || (0, _semver.gt)(ver, latestWithRegistry.version)) {
+                latestWithRegistry.key = key;
+                latestWithRegistry.version = ver;
+            }
+        } else {
+            if (!latestWithoutRegistry.key || (0, _semver.gt)(ver, latestWithoutRegistry.version)) {
+                latestWithoutRegistry.key = key;
+                latestWithoutRegistry.version = ver;
+            }
+        }
+    }
+    // Determine the best fallback key from the two buckets
+    let fallbackKey;
+    if (latestWithRegistry.key && latestWithoutRegistry.key) {
+        const { registryOverVersion } = precedenceLogic;
+        if ((0, _semver.gt)(latestWithRegistry.version, latestWithoutRegistry.version)) {
+            fallbackKey = latestWithRegistry.key;
+        } else if ((0, _semver.gt)(latestWithoutRegistry.version, latestWithRegistry.version)) {
+            fallbackKey = latestWithoutRegistry.key;
+        } else {
+            // Versions are equal — use the tie-breaker
+            fallbackKey = registryOverVersion ? latestWithRegistry.key : latestWithoutRegistry.key;
+        }
+    } else {
+        fallbackKey = latestWithRegistry.key || latestWithoutRegistry.key || undefined;
+    }
+    if (fallbackKey && !candidates.includes(fallbackKey)) {
+        candidates.push(fallbackKey);
+    }
+    return candidates;
+};

package/dist/cjs/components/PluginRegistry/plugin-indexes.js

@@ -21,14 +21,15 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get getTypeAndKindKey () {
-        return getTypeAndKindKey;
+    get getPluginModuleCompoundKey () {
+        return _model.getPluginModuleCompoundKey;
     },
     get usePluginIndexes () {
         return usePluginIndexes;
     }
 });
 const _react = require("react");
+const _model = require("../../model");
 const _utils = require("../../utils");
 function usePluginIndexes(getInstalledPlugins) {
     // Creates indexes from the installed plugins data (does useEvent because this accesses the getInstalledPlugins prop
@@ -36,17 +37,22 @@ function usePluginIndexes(getInstalledPlugins) {
     const createPluginIndexes = (0, _utils.useEvent)(async ()=>{
         const installedPlugins = await getInstalledPlugins();
         // Create the two indexes from the installed plugins
-        const pluginResourcesByNameAndKind = new Map();
+        const pluginResourcesByNameKindRegistryVersion = new Map();
         const pluginMetadataByKind = new Map();
         for (const resource of installedPlugins){
+            const { metadata: { version, registry } } = resource;
             for (const pluginMetadata of resource.spec.plugins){
                 const { kind, spec: { name } } = pluginMetadata;
-                // Index the plugin by type and kind to point at the module that contains it
-                const key = getTypeAndKindKey(kind, name);
-                if (pluginResourcesByNameAndKind.has(key)) {
-                    console.warn(`Got more than one ${kind} plugin for kind ${name}`);
+                const key = (0, _model.getPluginModuleCompoundKey)({
+                    kind,
+                    name,
+                    registry,
+                    version
+                });
+                if (pluginResourcesByNameKindRegistryVersion.has(key)) {
+                    console.warn(`Got more than one ${kind} plugin for kind ${name}, registry '${registry || 'undefined'}', and version '${version || 'undefined'}'`);
                 }
-                pluginResourcesByNameAndKind.set(key, resource);
+                pluginResourcesByNameKindRegistryVersion.set(key, resource);
                 // Index the metadata by plugin type
                 let list = pluginMetadataByKind.get(kind);
                 if (list === undefined) {
@@ -60,7 +66,7 @@ function usePluginIndexes(getInstalledPlugins) {
             }
         }
         return {
-            pluginResourcesByNameAndKind,
+            pluginResourcesByNameKindRegistryVersion,
             pluginMetadataByKind
         };
     });
@@ -72,7 +78,7 @@ function usePluginIndexes(getInstalledPlugins) {
             request = createPluginIndexes();
             pluginIndexesCache.current = request;
             // Remove failed requests from the cache so they can potentially be retried
-            request.catch(()=>pluginIndexesCache.current === undefined);
+            request.catch(()=>pluginIndexesCache.current = undefined);
         }
         return request;
     }, [
@@ -80,6 +86,3 @@ function usePluginIndexes(getInstalledPlugins) {
     ]);
     return getPluginIndexes;
 }
-function getTypeAndKindKey(kind, name) {
-    return `${kind}:${name}`;
-}

package/dist/cjs/components/Variables/VariableEditorForm/VariableEditorForm.js

@@ -27,7 +27,6 @@ const _components = require("@perses-dev/components");
 const _reacthookform = require("react-hook-form");
 const _zod = require("@hookform/resolvers/zod");
 const _reactquery = require("@tanstack/react-query");
-const _utils = require("../../../utils");
 const _PluginEditor = require("../../PluginEditor");
 const _context = require("../../../context");
 const _variablemodel = require("../variable-model");
@@ -395,8 +394,8 @@ function ListVariableEditorForm({ action, control }) {
 }
 function VariableEditorForm({ initialVariableDefinition, action, isDraft, isReadonly, onActionChange, onSave, onClose, onDelete }) {
     const [isDiscardDialogOpened, setDiscardDialogOpened] = (0, _react.useState)(false);
-    const titleAction = (0, _utils.getTitleAction)(action, isDraft);
-    const submitText = (0, _utils.getSubmitText)(action, isDraft);
+    const titleAction = (0, _components.getTitleAction)(action, isDraft);
+    const submitText = (0, _components.getSubmitText)(action, isDraft);
     const { variableEditorSchema } = (0, _context.useValidationSchemas)();
     const form = (0, _reacthookform.useForm)({
         resolver: (0, _zod.zodResolver)(variableEditorSchema),

package/dist/cjs/components/Variables/variable-model.js

@@ -32,9 +32,13 @@ _export(exports, {
     },
     get useListVariablePluginValues () {
         return useListVariablePluginValues;
+    },
+    get useResolveListVariableValues () {
+        return useResolveListVariableValues;
     }
 });
 const _reactquery = require("@tanstack/react-query");
+const _react = require("react");
 const _runtime = require("../../runtime");
 function filterVariableList(data, capturedRegexp) {
     const result = [];
@@ -61,54 +65,136 @@ function filterVariableList(data, capturedRegexp) {
     }
     return result;
 }
-function useListVariablePluginValues(definition) {
-    const { data: variablePlugin } = (0, _runtime.usePlugin)('Variable', definition.spec.plugin.kind);
+function useVariablePluginContext() {
     const datasourceStore = (0, _runtime.useDatasourceStore)();
     const allVariables = (0, _runtime.useAllVariableValues)();
     const { absoluteTimeRange: timeRange } = (0, _runtime.useTimeRange)();
-    const variablePluginCtx = {
+    return {
         timeRange,
         datasourceStore,
         variables: allVariables
     };
-    const spec = definition.spec.plugin.spec;
+}
+const getVariableQueryConfig = (definition, variablePluginCtx, variablePlugin, enabled, onFetched)=>{
     const capturingRegexp = definition.spec.capturingRegexp !== undefined ? new RegExp(definition.spec.capturingRegexp, 'g') : undefined;
-    let dependsOnVariables = Object.keys(allVariables); // Default to all variables
-    if (variablePlugin?.dependsOn) {
-        const dependencies = variablePlugin.dependsOn(spec, variablePluginCtx);
-        dependsOnVariables = dependencies.variables ? dependencies.variables : dependsOnVariables;
-    }
-    // Exclude self variable to avoid circular dependency
-    dependsOnVariables = dependsOnVariables.filter((v)=>v !== definition.spec.name);
-    const variables = (0, _runtime.useAllVariableValues)(dependsOnVariables);
-    let waitToLoad = false;
-    if (dependsOnVariables) {
-        waitToLoad = dependsOnVariables.some((v)=>variables[v]?.loading);
-    }
-    const variablesValueKey = getVariableValuesKey(variables);
-    return (0, _reactquery.useQuery)({
+    const variablesValueKey = getVariableValuesKey(variablePluginCtx.variables);
+    return {
         queryKey: [
             'variable',
             definition,
-            timeRange,
+            variablePluginCtx.timeRange,
             variablesValueKey
         ],
         queryFn: async ({ signal })=>{
-            const resp = await variablePlugin?.getVariableOptions(spec, {
-                datasourceStore,
-                variables,
-                timeRange
-            }, signal);
+            const resp = await variablePlugin?.getVariableOptions(definition.spec.plugin.spec, variablePluginCtx, signal);
             if (!resp?.data?.length) {
+                onFetched?.(definition.spec.name, [], definition);
                 return [];
             }
-            if (!capturingRegexp) {
-                return resp.data;
-            }
-            return filterVariableList(resp.data, capturingRegexp);
+            const options = capturingRegexp ? filterVariableList(resp.data, capturingRegexp) : resp.data;
+            onFetched?.(definition.spec.name, options, definition);
+            return options;
         },
-        enabled: !!variablePlugin || waitToLoad
+        enabled
+    };
+};
+function resolveDependsOnVariables(variablePlugin, variablePluginCtx, definition) {
+    if (variablePlugin?.dependsOn) {
+        const dependencies = variablePlugin.dependsOn(definition.spec.plugin.spec, variablePluginCtx);
+        return dependencies.variables ? dependencies.variables.filter((v)=>v !== definition.spec.name) : []; // Exclude self variable to avoid circular dependency and default to empty array to avoid deadlock
+    }
+    return [];
+}
+function useListVariablePluginValues(definition) {
+    const { data: variablePlugin } = (0, _runtime.usePlugin)('Variable', definition.spec.plugin.kind);
+    const variablePluginCtx = useVariablePluginContext();
+    const dependsOnVariables = resolveDependsOnVariables(variablePlugin, variablePluginCtx, definition);
+    const dependentVariables = (0, _runtime.useAllVariableValues)(dependsOnVariables);
+    const waitToLoad = dependsOnVariables.some((v)=>dependentVariables[v]?.loading);
+    const ctx = {
+        ...variablePluginCtx,
+        variables: dependentVariables
+    };
+    return (0, _reactquery.useQuery)(getVariableQueryConfig(definition, ctx, variablePlugin, !!variablePlugin && !waitToLoad));
+}
+function resolveDefaultValue(definition, options) {
+    const { defaultValue, allowMultiple } = definition.spec;
+    if (defaultValue !== undefined && defaultValue !== null) {
+        return defaultValue;
+    }
+    if (options[0]?.value) {
+        const first = options[0].value;
+        return allowMultiple ? [
+            first
+        ] : first;
+    }
+    return allowMultiple ? [] : '';
+}
+function useResolveListVariableValues(variableDefinitions) {
+    const { timeRange, datasourceStore, variables: outerVariableValues } = useVariablePluginContext();
+    const listVariables = (0, _react.useMemo)(()=>variableDefinitions.filter((v)=>v.kind === 'ListVariable'), [
+        variableDefinitions
+    ]);
+    const pluginResults = (0, _runtime.usePlugins)('Variable', listVariables.map((d)=>({
+            kind: d.spec.plugin.kind
+        })));
+    // Resolved variable state. Updated by onFetched when queries resolve.
+    // Needed because of dependencies between variables that require multiple rounds of fetching.
+    const [resolvedVariables, setResolvedVariables] = (0, _react.useState)({});
+    const allVariables = (0, _react.useMemo)(()=>{
+        return {
+            ...outerVariableValues,
+            ...resolvedVariables
+        };
+    }, [
+        outerVariableValues,
+        resolvedVariables
+    ]);
+    const onFetched = (0, _react.useCallback)((name, options, definition)=>{
+        setResolvedVariables((prev)=>({
+                ...prev,
+                [name]: {
+                    value: resolveDefaultValue(definition, options),
+                    loading: false,
+                    options
+                }
+            }));
+    }, []);
+    const queryResults = (0, _reactquery.useQueries)({
+        queries: listVariables.map((definition, index)=>{
+            const plugin = pluginResults[index]?.data;
+            const isPluginLoading = pluginResults[index]?.isLoading ?? true;
+            const dependsOn = resolveDependsOnVariables(plugin, {
+                timeRange,
+                datasourceStore,
+                variables: allVariables
+            }, definition);
+            const hasPendingDeps = dependsOn.some((v)=>resolvedVariables[v] === undefined && listVariables.some((lv)=>lv.spec.name === v) || allVariables[v]?.loading);
+            const dependentVariables = {};
+            for (const v of dependsOn){
+                const state = allVariables[v];
+                if (state) {
+                    dependentVariables[v] = state;
+                }
+            }
+            const ctx = {
+                timeRange,
+                datasourceStore,
+                variables: dependentVariables
+            };
+            return getVariableQueryConfig(definition, ctx, plugin, !hasPendingDeps && !isPluginLoading, onFetched);
+        })
     });
+    const initialVariableValues = (0, _react.useMemo)(()=>Object.fromEntries(Object.entries(allVariables).filter(([, state])=>state?.value !== undefined).map(([name, state])=>[
+                name,
+                state.value
+            ])), [
+        allVariables
+    ]);
+    return {
+        initialVariableValues,
+        isLoading: queryResults.some((r)=>r.isLoading)
+    };
 }
 function getVariableValuesKey(v) {
     return Object.values(v).map((v)=>JSON.stringify(v.value)).join(',');

package/dist/cjs/context/ValidationProvider.js

@@ -34,7 +34,7 @@ _export(exports, {
 const _jsxruntime = require("react/jsx-runtime");
 const _react = require("react");
 const _spec = require("@perses-dev/spec");
-const _core = require("@perses-dev/core");
+const _client = require("@perses-dev/client");
 const ValidationSchemasContext = /*#__PURE__*/ (0, _react.createContext)(undefined);
 function useValidationSchemas() {
     const ctx = (0, _react.useContext)(ValidationSchemasContext);
@@ -44,11 +44,11 @@ function useValidationSchemas() {
     return ctx;
 }
 function ValidationProvider({ children }) {
-    const [datasourceEditorSchema, setDatasourceEditorSchema] = (0, _react.useState)(_core.datasourceDefinitionSchema);
+    const [datasourceEditorSchema, setDatasourceEditorSchema] = (0, _react.useState)(_client.datasourceDefinitionSchema);
     const [panelEditorSchema, setPanelEditorSchema] = (0, _react.useState)(_spec.panelEditorSchema); // TODO I don't get why this does not compile
     const [variableEditorSchema, setVariableEditorSchema] = (0, _react.useState)(_spec.variableDefinitionSchema);
     function setDatasourceEditorSchemaPlugin(pluginSchema) {
-        setDatasourceEditorSchema((0, _core.buildDatasourceDefinitionSchema)(pluginSchema));
+        setDatasourceEditorSchema((0, _client.buildDatasourceDefinitionSchema)(pluginSchema));
     }
     function setPanelEditorSchemaPlugin(pluginSchema) {
         setPanelEditorSchema((0, _spec.buildPanelEditorSchema)(pluginSchema));

package/dist/cjs/model/alerts-queries.js

@@ -0,0 +1,16 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});