@grafana/create-plugin 1.0.0 → 1.0.1-canary.210.207e8c7.0

package/dist/commands/migrate.command.js

@@ -85,11 +85,11 @@ var migrate = function () { return __awaiter(void 0, void 0, void 0, function ()
                 }
                 _a.label = 5;
             case 5:
-                if (!(0, utils_npm_1.hasNpmDependenciesToUpdate)()) return [3, 7];
-                return [4, (0, utils_console_1.confirmPrompt)(constants_1.TEXT.updateNpmDependenciesPrompt + (0, utils_npm_1.getPackageJsonUpdatesAsText)({ ignoreGrafanaDependencies: true }))];
+                if (!(0, utils_npm_1.hasNpmDependenciesToUpdate)({ dontUpdateGrafanaDependencies: true })) return [3, 7];
+                return [4, (0, utils_console_1.confirmPrompt)(constants_1.TEXT.updateNpmDependenciesPrompt + (0, utils_npm_1.getPackageJsonUpdatesAsText)({ dontUpdateGrafanaDependencies: true }))];
             case 6:
                 if (_a.sent()) {
-                    (0, utils_npm_1.updatePackageJson)({ ignoreGrafanaDependencies: true });
+                    (0, utils_npm_1.updatePackageJson)({ dontUpdateGrafanaDependencies: true });
                     (0, utils_console_1.printSuccessMessage)(constants_1.TEXT.updateNpmDependenciesSuccess);
                 }
                 else {

package/dist/commands/update.command.js

@@ -41,60 +41,113 @@ var constants_1 = require("../constants");
 var utils_templates_1 = require("../utils/utils.templates");
 var utils_console_1 = require("../utils/utils.console");
 var utils_npm_1 = require("../utils/utils.npm");
+function updateConfigurationFiles() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, (0, utils_console_1.confirmPrompt)(constants_1.TEXT.updateConfigPrompt)];
+                case 1:
+                    if (_a.sent()) {
+                        (0, utils_templates_1.compileTemplateFiles)(constants_1.UDPATE_CONFIG.filesToOverride, (0, utils_templates_1.getTemplateData)());
+                        (0, utils_console_1.printSuccessMessage)(constants_1.TEXT.overrideFilesSuccess);
+                    }
+                    else {
+                        (0, utils_console_1.printMessage)(constants_1.TEXT.overrideFilesAborted);
+                        process.exit(0);
+                    }
+                    return [2];
+            }
+        });
+    });
+}
+function updateNpmDependencies() {
+    return __awaiter(this, void 0, void 0, function () {
+        var shouldUpdateGrafanaPackages, updatadableDependenciesText, PROMPT_CHOICES, shouldUpdateDeps;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(0, utils_npm_1.hasNpmDependenciesToUpdate)()) return [3, 3];
+                    return [4, (0, utils_console_1.confirmPrompt)(constants_1.TEXT.updateNpmGrafanaPackagesPrompt)];
+                case 1:
+                    shouldUpdateGrafanaPackages = _a.sent();
+                    updatadableDependenciesText = (0, utils_npm_1.getPackageJsonUpdatesAsText)({
+                        dontUpdateGrafanaDependencies: !shouldUpdateGrafanaPackages
+                    });
+                    if (updatadableDependenciesText.length === 0) {
+                        return [2];
+                    }
+                    PROMPT_CHOICES = {
+                        ALL: 'Yes, all of them',
+                        ONLY_OUTDATED: 'Yes, but only the outdated ones',
+                        NONE: 'No'
+                    };
+                    return [4, (0, utils_console_1.selectPrompt)(constants_1.TEXT.updateNpmDependenciesPrompt + updatadableDependenciesText, [
+                            PROMPT_CHOICES.ALL,
+                            PROMPT_CHOICES.ONLY_OUTDATED,
+                            PROMPT_CHOICES.NONE,
+                        ])];
+                case 2:
+                    shouldUpdateDeps = _a.sent();
+                    if (shouldUpdateDeps && shouldUpdateDeps !== PROMPT_CHOICES.NONE) {
+                        (0, utils_npm_1.updatePackageJson)({
+                            dontUpdateGrafanaDependencies: !shouldUpdateGrafanaPackages,
+                            onlyOutdated: shouldUpdateDeps === PROMPT_CHOICES.ONLY_OUTDATED
+                        });
+                        (0, utils_console_1.printSuccessMessage)(constants_1.TEXT.updateNpmDependenciesSuccess);
+                    }
+                    else {
+                        (0, utils_console_1.printMessage)(constants_1.TEXT.updateNpmDependenciesAborted);
+                    }
+                    return [3, 4];
+                case 3:
+                    (0, utils_console_1.printMessage)(constants_1.TEXT.updateNpmDependenciesAborted);
+                    _a.label = 4;
+                case 4: return [2];
+            }
+        });
+    });
+}
+function updatePackageJsonScripts() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, (0, utils_console_1.confirmPrompt)(constants_1.TEXT.updateNpmScriptsPrompt)];
+                case 1:
+                    if (_a.sent()) {
+                        (0, utils_npm_1.updateNpmScripts)();
+                        (0, utils_console_1.printSuccessMessage)(constants_1.TEXT.updateNpmScriptsSuccess);
+                    }
+                    else {
+                        (0, utils_console_1.printMessage)(constants_1.TEXT.updateNpmScriptsAborted);
+                    }
+                    return [2];
+            }
+        });
+    });
+}
 var update = function () { return __awaiter(void 0, void 0, void 0, function () {
-    var PROMPT_CHOICES, shouldUpdateDeps, error_1;
+    var error_1;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                _a.trys.push([0, 5, , 6]);
+                _a.trys.push([0, 4, , 5]);
                 (0, utils_console_1.printMessage)(constants_1.TEXT.updateCommandWarning);
-                return [4, (0, utils_console_1.confirmPrompt)(constants_1.TEXT.updateConfigPrompt)];
+                return [4, updateConfigurationFiles()];
             case 1:
-                if (_a.sent()) {
-                    (0, utils_templates_1.compileTemplateFiles)(constants_1.UDPATE_CONFIG.filesToOverride, (0, utils_templates_1.getTemplateData)());
-                    (0, utils_console_1.printSuccessMessage)(constants_1.TEXT.overrideFilesSuccess);
-                }
-                else {
-                    (0, utils_console_1.printMessage)(constants_1.TEXT.overrideFilesAborted);
-                    process.exit(0);
-                }
-                if (!(0, utils_npm_1.hasNpmDependenciesToUpdate)()) return [3, 3];
-                PROMPT_CHOICES = {
-                    ALL: 'Yes, all of them',
-                    ONLY_OUTDATED: 'Yes, but only the outdated ones',
-                    NONE: 'No'
-                };
-                return [4, (0, utils_console_1.selectPrompt)(constants_1.TEXT.updateNpmDependenciesPrompt + (0, utils_npm_1.getPackageJsonUpdatesAsText)(), [
-                        PROMPT_CHOICES.ALL,
-                        PROMPT_CHOICES.ONLY_OUTDATED,
-                        PROMPT_CHOICES.NONE,
-                    ])];
+                _a.sent();
+                return [4, updateNpmDependencies()];
             case 2:
-                shouldUpdateDeps = _a.sent();
-                if (shouldUpdateDeps && shouldUpdateDeps !== PROMPT_CHOICES.NONE) {
-                    (0, utils_npm_1.updatePackageJson)({ onlyOutdated: shouldUpdateDeps === PROMPT_CHOICES.ONLY_OUTDATED });
-                    (0, utils_console_1.printSuccessMessage)(constants_1.TEXT.updateNpmDependenciesSuccess);
-                }
-                else {
-                    (0, utils_console_1.printMessage)(constants_1.TEXT.updateNpmDependenciesAborted);
-                }
-                _a.label = 3;
-            case 3: return [4, (0, utils_console_1.confirmPrompt)(constants_1.TEXT.updateNpmScriptsPrompt)];
-            case 4:
-                if (_a.sent()) {
-                    (0, utils_npm_1.updateNpmScripts)();
-                    (0, utils_console_1.printSuccessMessage)(constants_1.TEXT.updateNpmScriptsSuccess);
-                }
-                else {
-                    (0, utils_console_1.printMessage)(constants_1.TEXT.updateNpmScriptsAborted);
-                }
+                _a.sent();
+                return [4, updatePackageJsonScripts()];
+            case 3:
+                _a.sent();
                 (0, utils_console_1.printSuccessMessage)(constants_1.TEXT.updateCommandSuccess);
-                return [3, 6];
-            case 5:
+                return [3, 5];
+            case 4:
                 error_1 = _a.sent();
                 console.error(error_1);
-                return [3, 6];
-            case 6: return [2];
+                return [3, 5];
+            case 5: return [2];
         }
     });
 }); };

package/dist/constants.js

@@ -72,6 +72,7 @@ exports.TEXT = {
     updateNpmDependenciesPrompt: '**Would you like to update the following dependencies in the `package.json?`**',
     updateNpmDependenciesSuccess: 'Successfully updated the NPM dependencies.',
     updateNpmDependenciesAborted: 'No NPM dependencies have been updated.',
+    updateNpmGrafanaPackagesPrompt: 'Would you like to update the `@grafana/*` packages dependencies?',
     removeNpmDependenciesPrompt: '**Would you like to remove the following possibly unnecessary NPM dependencies?**',
     removeNpmDependenciesSuccess: 'Unnecessary NPM dependencies removed successfully.',
     removeNpmDependenciesAborted: 'No NPM dependencies have been removed.',

package/dist/utils/tests/utils.npm.test.js

@@ -1,6 +1,67 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 exports.__esModule = true;
+var files = __importStar(require("../utils.files"));
 var utils_npm_1 = require("../utils.npm");
+var templates = __importStar(require("../utils.templates"));
 describe('Utils / NPM', function () {
     describe('getDepenciesToBeUpdated()', function () {
         test('it should return a summary of dependencies to be updated', function () {
@@ -135,4 +196,83 @@ describe('Utils / NPM', function () {
             });
         });
     });
+    describe('getPackageJsonUpdates()', function () {
+        var spies;
+        beforeEach(function () {
+            spies = [
+                jest.spyOn(templates, 'renderTemplateFromFile').mockReturnValue(JSON.stringify({
+                    scripts: {},
+                    dependencies: {
+                        '@emotion/css': '^11.1.3',
+                        '@grafana/data': '9.3.0',
+                        '@grafana/runtime': '9.3.0',
+                        '@grafana/ui': '9.3.0'
+                    },
+                    devDependencies: {
+                        '@babel/core': '^7.16.7',
+                        '@grafana/e2e': '{{ grafanaVersion }}',
+                        '@grafana/e2e-selectors': '{{ grafanaVersion }}',
+                        '@grafana/eslint-config': '^5.1.0',
+                        '@grafana/tsconfig': '^1.2.0-rc1',
+                        '@swc/core': '^1.2.144'
+                    }
+                })),
+                jest.spyOn(files, 'readJsonFile').mockImplementation(function () {
+                    return {
+                        dependencies: {
+                            '@grafana/data': '9.0.0',
+                            '@grafana/runtime': '9.0.0',
+                            underscore: '2.0.0'
+                        },
+                        devDependencies: {
+                            'eslint-plugin-react': '7.26.1'
+                        }
+                    };
+                }),
+            ];
+        });
+        afterEach(function () {
+            spies.forEach(function (s) { return s.mockRestore(); });
+        });
+        it('updates @grafana dependencies by default', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                result = (0, utils_npm_1.getPackageJsonUpdates)({ dontUpdateGrafanaDependencies: false });
+                expect(result.dependencyUpdates['@grafana/data']).toBeDefined();
+                expect(result.dependencyUpdates['@grafana/runtime']).toBeDefined();
+                expect(result.devDependencyUpdates['@grafana/data']).not.toBeDefined();
+                expect(result.devDependencyUpdates['@grafana/runtime']).not.toBeDefined();
+                return [2];
+            });
+        }); });
+        it('does not update @grafana dependencies when instructed', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                result = (0, utils_npm_1.getPackageJsonUpdates)({ dontUpdateGrafanaDependencies: true });
+                expect(result.dependencyUpdates['@grafana/data'].next).toEqual(result.dependencyUpdates['@grafana/data'].prev);
+                expect(result.dependencyUpdates['@grafana/runtime'].next).toEqual(result.dependencyUpdates['@grafana/runtime'].prev);
+                return [2];
+            });
+        }); });
+        it('moves @grafana/* dependencies from devDependencies to dependencies when instructed keeping their version', function () {
+            var spy = jest.spyOn(files, 'readJsonFile').mockImplementation(function () {
+                return {
+                    dependencies: {
+                        underscore: '2.0.0'
+                    },
+                    devDependencies: {
+                        'eslint-plugin-react': '7.26.1',
+                        '@grafana/data': '9.0.0',
+                        '@grafana/runtime': '9.0.0'
+                    }
+                };
+            });
+            var result = (0, utils_npm_1.getPackageJsonUpdates)({ dontUpdateGrafanaDependencies: true });
+            expect(result.dependencyUpdates['@grafana/data'].next).toEqual(result.dependencyUpdates['@grafana/data'].prev);
+            expect(result.dependencyUpdates['@grafana/runtime'].next).toEqual(result.dependencyUpdates['@grafana/runtime'].prev);
+            expect(result.devDependencyUpdates['@grafana/data']).not.toBeDefined();
+            expect(result.devDependencyUpdates['@grafana/runtime']).not.toBeDefined();
+            spy.mockRestore();
+        });
+    });
 });

package/dist/utils/utils.npm.js

@@ -38,7 +38,7 @@ exports.writePackageJson = writePackageJson;
 function getNpmDependencyUpdatesAsText(dependencyUpdates) {
     return Object.entries(dependencyUpdates)
         .filter(function (_a) {
-        var packageName = _a[0], _b = _a[1], prev = _b.prev, next = _b.next;
+        var _ = _a[0], _b = _a[1], prev = _b.prev, next = _b.next;
         return prev !== next;
     })
         .map(function (_a) {
@@ -96,50 +96,33 @@ function getPackageJsonUpdates(options) {
     var devDependencies = packageJson.devDependencies || {};
     var newDependencies = newPackageJson.dependencies || {};
     var newDevDependencies = newPackageJson.devDependencies || {};
+    for (var _i = 0, GRAFANA_FE_PACKAGES_1 = constants_1.GRAFANA_FE_PACKAGES; _i < GRAFANA_FE_PACKAGES_1.length; _i++) {
+        var grafanaPackage = GRAFANA_FE_PACKAGES_1[_i];
+        if (devDependencies[grafanaPackage]) {
+            dependencies[grafanaPackage] = devDependencies[grafanaPackage];
+            delete devDependencies[grafanaPackage];
+        }
+    }
     var dependencyUpdates = getUpdatableNpmDependencies(dependencies, newDependencies, options);
     var devDependencyUpdates = getUpdatableNpmDependencies(devDependencies, newDevDependencies, options);
-    if (options.ignoreGrafanaDependencies) {
-        var prevGrafanaDependencies = Object.entries(__assign(__assign({}, dependencies), devDependencies)).reduce(function (acc, _a) {
-            var key = _a[0], value = _a[1];
-            if (constants_1.GRAFANA_FE_PACKAGES.includes(key)) {
-                acc[key] = value;
-            }
-            return acc;
-        }, {});
-        return {
-            dependencyUpdates: ignoreGrafanaDependencies(dependencyUpdates, prevGrafanaDependencies),
-            devDependencyUpdates: ignoreGrafanaDependencies(devDependencyUpdates, prevGrafanaDependencies)
-        };
-    }
     return {
         dependencyUpdates: dependencyUpdates,
         devDependencyUpdates: devDependencyUpdates
     };
 }
 exports.getPackageJsonUpdates = getPackageJsonUpdates;
-function ignoreGrafanaDependencies(dependencyUpdates, prevGrafanaDependencies) {
-    var whatever = Object.keys(prevGrafanaDependencies);
-    var result = Object.entries(dependencyUpdates).reduce(function (acc, _a) {
-        var packageName = _a[0], value = _a[1];
-        if (whatever.includes(packageName)) {
-            acc[packageName] = {
-                prev: prevGrafanaDependencies[packageName],
-                next: prevGrafanaDependencies[packageName]
-            };
-        }
-        else {
-            acc[packageName] = value;
-        }
-        return acc;
-    }, {});
-    return result;
-}
 function getUpdatableNpmDependencies(prevDeps, nextDeps, options) {
     if (options === void 0) { options = {}; }
     var updateSummary = {};
     for (var _i = 0, _a = Object.entries(nextDeps); _i < _a.length; _i++) {
         var _b = _a[_i], packageName = _b[0], newSemverRange = _b[1];
         var currentSemverRange = prevDeps[packageName];
+        if (options.dontUpdateGrafanaDependencies && constants_1.GRAFANA_FE_PACKAGES.includes(packageName)) {
+            if (currentSemverRange) {
+                updateSummary[packageName] = { prev: currentSemverRange, next: currentSemverRange };
+            }
+            continue;
+        }
         if (!currentSemverRange) {
             updateSummary[packageName] = { prev: null, next: newSemverRange };
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grafana/create-plugin",
-  "version": "1.0.0",
+  "version": "1.0.1-canary.210.207e8c7.0",
   "main": "index.js",
   "repository": {
     "directory": "packages/create-plugin",
@@ -60,5 +60,5 @@
   "engines": {
     "node": ">=16"
   },
-  "gitHead": "1b6746b0c95271772741cf1a8cba405919f53874"
+  "gitHead": "207e8c72cf7509ce7d29526db5df3a916d8db1c1"
 }

package/src/commands/migrate.command.ts

@@ -57,13 +57,13 @@ export const migrate = async () => {
     // 4. Add / update dependencies inside the `package.json`
     // (skipped automatically if there is nothing to update)
     // ------------------------------------------------
-    if (hasNpmDependenciesToUpdate()) {
+    if (hasNpmDependenciesToUpdate({ dontUpdateGrafanaDependencies: true })) {
       if (
         await confirmPrompt(
-          TEXT.updateNpmDependenciesPrompt + getPackageJsonUpdatesAsText({ ignoreGrafanaDependencies: true })
+          TEXT.updateNpmDependenciesPrompt + getPackageJsonUpdatesAsText({ dontUpdateGrafanaDependencies: true })
         )
       ) {
-        updatePackageJson({ ignoreGrafanaDependencies: true });
+        updatePackageJson({ dontUpdateGrafanaDependencies: true });
         printSuccessMessage(TEXT.updateNpmDependenciesSuccess);
       } else {
         printMessage(TEXT.updateNpmDependenciesAborted);

package/src/commands/update.command.ts

@@ -8,54 +8,79 @@ import {
   updateNpmScripts,
 } from '../utils/utils.npm';
 
+async function updateConfigurationFiles() {
+  if (await confirmPrompt(TEXT.updateConfigPrompt)) {
+    compileTemplateFiles(UDPATE_CONFIG.filesToOverride, getTemplateData());
+    printSuccessMessage(TEXT.overrideFilesSuccess);
+  } else {
+    printMessage(TEXT.overrideFilesAborted);
+    process.exit(0);
+  }
+}
+
+async function updateNpmDependencies() {
+  if (hasNpmDependenciesToUpdate()) {
+    //  ask if we should update the grafana dependencies
+    const shouldUpdateGrafanaPackages = await confirmPrompt(TEXT.updateNpmGrafanaPackagesPrompt);
+
+    const updatadableDependenciesText = getPackageJsonUpdatesAsText({
+      dontUpdateGrafanaDependencies: !shouldUpdateGrafanaPackages,
+    });
+
+    if (updatadableDependenciesText.length === 0) {
+      // No dependencies to update
+      return;
+    }
+
+    const PROMPT_CHOICES = {
+      ALL: 'Yes, all of them',
+      ONLY_OUTDATED: 'Yes, but only the outdated ones',
+      NONE: 'No',
+    };
+
+    const shouldUpdateDeps = await selectPrompt(TEXT.updateNpmDependenciesPrompt + updatadableDependenciesText, [
+      PROMPT_CHOICES.ALL,
+      PROMPT_CHOICES.ONLY_OUTDATED,
+      PROMPT_CHOICES.NONE,
+    ]);
+
+    if (shouldUpdateDeps && shouldUpdateDeps !== PROMPT_CHOICES.NONE) {
+      updatePackageJson({
+        dontUpdateGrafanaDependencies: !shouldUpdateGrafanaPackages,
+        onlyOutdated: shouldUpdateDeps === PROMPT_CHOICES.ONLY_OUTDATED,
+      });
+      printSuccessMessage(TEXT.updateNpmDependenciesSuccess);
+    } else {
+      printMessage(TEXT.updateNpmDependenciesAborted);
+    }
+  } else {
+    printMessage(TEXT.updateNpmDependenciesAborted);
+  }
+}
+
+async function updatePackageJsonScripts() {
+  if (await confirmPrompt(TEXT.updateNpmScriptsPrompt)) {
+    updateNpmScripts();
+    printSuccessMessage(TEXT.updateNpmScriptsSuccess);
+  } else {
+    printMessage(TEXT.updateNpmScriptsAborted);
+  }
+}
+
 export const update = async () => {
   try {
-    // 0. Warning
-    // ----------
     printMessage(TEXT.updateCommandWarning);
 
     // 1. Add / update configuration files
-    // -----------------------------------
-    if (await confirmPrompt(TEXT.updateConfigPrompt)) {
-      compileTemplateFiles(UDPATE_CONFIG.filesToOverride, getTemplateData());
-      printSuccessMessage(TEXT.overrideFilesSuccess);
-    } else {
-      printMessage(TEXT.overrideFilesAborted);
-      process.exit(0);
-    }
+    await updateConfigurationFiles();
 
     // 2. Add / update dependencies inside the `package.json`
     // (skipped automatically if there is nothing to update)
-    // ------------------------------------------------
-    if (hasNpmDependenciesToUpdate()) {
-      const PROMPT_CHOICES = {
-        ALL: 'Yes, all of them',
-        ONLY_OUTDATED: 'Yes, but only the outdated ones',
-        NONE: 'No',
-      };
-      const shouldUpdateDeps = await selectPrompt(TEXT.updateNpmDependenciesPrompt + getPackageJsonUpdatesAsText(), [
-        PROMPT_CHOICES.ALL,
-        PROMPT_CHOICES.ONLY_OUTDATED,
-        PROMPT_CHOICES.NONE,
-      ]);
-
-      if (shouldUpdateDeps && shouldUpdateDeps !== PROMPT_CHOICES.NONE) {
-        updatePackageJson({ onlyOutdated: shouldUpdateDeps === PROMPT_CHOICES.ONLY_OUTDATED });
-        printSuccessMessage(TEXT.updateNpmDependenciesSuccess);
-      } else {
-        printMessage(TEXT.updateNpmDependenciesAborted);
-      }
-    }
+    await updateNpmDependencies();
 
     // 3. Add / update NPM scripts
     // (skipped automatically if there is nothing to update)
-    // ------------------------------------------------
-    if (await confirmPrompt(TEXT.updateNpmScriptsPrompt)) {
-      updateNpmScripts();
-      printSuccessMessage(TEXT.updateNpmScriptsSuccess);
-    } else {
-      printMessage(TEXT.updateNpmScriptsAborted);
-    }
+    await updatePackageJsonScripts();
 
     // 4. Summary
     // -------------

package/src/constants.ts

@@ -95,6 +95,7 @@ export const TEXT = {
   updateNpmDependenciesPrompt: '**Would you like to update the following dependencies in the `package.json?`**',
   updateNpmDependenciesSuccess: 'Successfully updated the NPM dependencies.',
   updateNpmDependenciesAborted: 'No NPM dependencies have been updated.',
+  updateNpmGrafanaPackagesPrompt: 'Would you like to update the `@grafana/*` packages dependencies?',
 
   removeNpmDependenciesPrompt: '**Would you like to remove the following possibly unnecessary NPM dependencies?**',
   removeNpmDependenciesSuccess: 'Unnecessary NPM dependencies removed successfully.',

package/src/utils/tests/utils.npm.test.ts

@@ -1,4 +1,6 @@
-import { updateNpmDependencies, getUpdatableNpmDependencies } from '../utils.npm';
+import * as files from '../utils.files';
+import { updateNpmDependencies, getUpdatableNpmDependencies, getPackageJsonUpdates } from '../utils.npm';
+import * as templates from '../utils.templates';
 
 describe('Utils / NPM', () => {
   describe('getDepenciesToBeUpdated()', () => {
@@ -190,4 +192,95 @@ describe('Utils / NPM', () => {
       });
     });
   });
+
+  describe('getPackageJsonUpdates()', () => {
+    let spies: jest.SpyInstance[];
+    beforeEach(() => {
+      spies = [
+        // template package.json
+        jest.spyOn(templates, 'renderTemplateFromFile').mockReturnValue(
+          JSON.stringify({
+            scripts: {},
+            dependencies: {
+              '@emotion/css': '^11.1.3',
+              '@grafana/data': '9.3.0',
+              '@grafana/runtime': '9.3.0',
+              '@grafana/ui': '9.3.0',
+            },
+            devDependencies: {
+              '@babel/core': '^7.16.7',
+              '@grafana/e2e': '{{ grafanaVersion }}',
+              '@grafana/e2e-selectors': '{{ grafanaVersion }}',
+              '@grafana/eslint-config': '^5.1.0',
+              '@grafana/tsconfig': '^1.2.0-rc1',
+              '@swc/core': '^1.2.144',
+            },
+          })
+        ),
+        // plugin package.json
+        jest.spyOn(files, 'readJsonFile').mockImplementation(() => {
+          return {
+            dependencies: {
+              '@grafana/data': '9.0.0',
+              '@grafana/runtime': '9.0.0',
+              underscore: '2.0.0',
+            },
+            devDependencies: {
+              'eslint-plugin-react': '7.26.1',
+            },
+          };
+        }),
+      ];
+    });
+
+    afterEach(() => {
+      spies.forEach((s) => s.mockRestore());
+    });
+
+    it('updates @grafana dependencies by default', async () => {
+      const result = getPackageJsonUpdates({ dontUpdateGrafanaDependencies: false }); // false by default
+      expect(result.dependencyUpdates['@grafana/data']).toBeDefined();
+      expect(result.dependencyUpdates['@grafana/runtime']).toBeDefined();
+      // shouldn't be in devDependencies
+      expect(result.devDependencyUpdates['@grafana/data']).not.toBeDefined();
+      expect(result.devDependencyUpdates['@grafana/runtime']).not.toBeDefined();
+    });
+
+    it('does not update @grafana dependencies when instructed', async () => {
+      // the plugin package.json
+      const result = getPackageJsonUpdates({ dontUpdateGrafanaDependencies: true });
+      expect(result.dependencyUpdates['@grafana/data'].next).toEqual(result.dependencyUpdates['@grafana/data'].prev);
+      expect(result.dependencyUpdates['@grafana/runtime'].next).toEqual(
+        result.dependencyUpdates['@grafana/runtime'].prev
+      );
+    });
+
+    it('moves @grafana/* dependencies from devDependencies to dependencies when instructed keeping their version', () => {
+      // the plugin package.json
+      const spy = jest.spyOn(files, 'readJsonFile').mockImplementation(() => {
+        return {
+          dependencies: {
+            underscore: '2.0.0',
+          },
+          devDependencies: {
+            'eslint-plugin-react': '7.26.1',
+            '@grafana/data': '9.0.0',
+            '@grafana/runtime': '9.0.0',
+          },
+        };
+      });
+      const result = getPackageJsonUpdates({ dontUpdateGrafanaDependencies: true });
+
+      // should be in dependencies
+      expect(result.dependencyUpdates['@grafana/data'].next).toEqual(result.dependencyUpdates['@grafana/data'].prev);
+      expect(result.dependencyUpdates['@grafana/runtime'].next).toEqual(
+        result.dependencyUpdates['@grafana/runtime'].prev
+      );
+      // should not be in devDependencies
+      expect(result.devDependencyUpdates['@grafana/data']).not.toBeDefined();
+      expect(result.devDependencyUpdates['@grafana/runtime']).not.toBeDefined();
+
+      spy.mockRestore();
+    });
+  });
 });

package/src/utils/utils.npm.ts

@@ -9,7 +9,7 @@ type UpdateSummary = Record<string, { prev: string | null; next: string | null }
 
 type UpdateOptions = {
   onlyOutdated?: Boolean;
-  ignoreGrafanaDependencies?: boolean;
+  dontUpdateGrafanaDependencies?: boolean;
 };
 
 type PackageJson = {
@@ -36,7 +36,7 @@ export function writePackageJson(json: PackageJson) {
 
 export function getNpmDependencyUpdatesAsText(dependencyUpdates: UpdateSummary) {
   return Object.entries(dependencyUpdates)
-    .filter(([packageName, { prev, next }]) => prev !== next)
+    .filter(([_, { prev, next }]) => prev !== next)
     .map(([packageName, { prev, next }]) => {
       // New package
       if (!prev) {
@@ -99,47 +99,24 @@ export function getPackageJsonUpdates(options: UpdateOptions = {}) {
   const devDependencies = packageJson.devDependencies || {};
   const newDependencies = newPackageJson.dependencies || {};
   const newDevDependencies = newPackageJson.devDependencies || {};
-  const dependencyUpdates = getUpdatableNpmDependencies(dependencies, newDependencies, options);
-  const devDependencyUpdates = getUpdatableNpmDependencies(devDependencies, newDevDependencies, options);
 
-  if (options.ignoreGrafanaDependencies) {
-    const prevGrafanaDependencies = Object.entries({ ...dependencies, ...devDependencies }).reduce<
-      Record<string, string>
-    >((acc, [key, value]) => {
-      if (GRAFANA_FE_PACKAGES.includes(key)) {
-        acc[key] = value;
-      }
-      return acc;
-    }, {});
-    return {
-      dependencyUpdates: ignoreGrafanaDependencies(dependencyUpdates, prevGrafanaDependencies),
-      devDependencyUpdates: ignoreGrafanaDependencies(devDependencyUpdates, prevGrafanaDependencies),
-    };
+  // Move grafana dependencies from devDependencies to dependencies
+  for (const grafanaPackage of GRAFANA_FE_PACKAGES) {
+    if (devDependencies[grafanaPackage]) {
+      dependencies[grafanaPackage] = devDependencies[grafanaPackage];
+      delete devDependencies[grafanaPackage];
+    }
   }
 
+  const dependencyUpdates = getUpdatableNpmDependencies(dependencies, newDependencies, options);
+  const devDependencyUpdates = getUpdatableNpmDependencies(devDependencies, newDevDependencies, options);
+
   return {
     dependencyUpdates,
     devDependencyUpdates,
   };
 }
 
-function ignoreGrafanaDependencies(dependencyUpdates: UpdateSummary, prevGrafanaDependencies: Record<string, string>) {
-  const whatever = Object.keys(prevGrafanaDependencies);
-  const result = Object.entries(dependencyUpdates).reduce<UpdateSummary>((acc, [packageName, value]) => {
-    if (whatever.includes(packageName)) {
-      acc[packageName] = {
-        prev: prevGrafanaDependencies[packageName],
-        next: prevGrafanaDependencies[packageName],
-      };
-    } else {
-      acc[packageName] = value;
-    }
-    return acc;
-  }, {});
-
-  return result;
-}
-
 export function getUpdatableNpmDependencies(
   prevDeps: Record<string, string>,
   nextDeps: Record<string, string>,
@@ -151,6 +128,14 @@ export function getUpdatableNpmDependencies(
   for (const [packageName, newSemverRange] of Object.entries(nextDeps)) {
     const currentSemverRange = prevDeps[packageName];
 
+    // keep grafana dependencies at the same version when instructed
+    if (options.dontUpdateGrafanaDependencies && GRAFANA_FE_PACKAGES.includes(packageName)) {
+      if (currentSemverRange) {
+        updateSummary[packageName] = { prev: currentSemverRange, next: currentSemverRange };
+      }
+      continue;
+    }
+
     // New dependency
     if (!currentSemverRange) {
       updateSummary[packageName] = { prev: null, next: newSemverRange };

package/templates/backend/pkg/plugin/datasource.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana-plugin-sdk-go/backend/instancemgmt"
-	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
 	"github.com/grafana/grafana-plugin-sdk-go/data"
 )
 
@@ -45,10 +44,6 @@ func (d *Datasource) Dispose() {
 // The QueryDataResponse contains a map of RefID to the response for each query, and each response
 // contains Frames ([]*Frame).
 func (d *Datasource) QueryData(ctx context.Context, req *backend.QueryDataRequest) (*backend.QueryDataResponse, error) {
-	// when logging at a non-Debug level, make sure you don't include sensitive information in the message
-	// (like the *backend.QueryDataRequest)
-	log.DefaultLogger.Debug("QueryData called", "numQueries", len(req.Queries))
-
 	// create response struct
 	response := backend.NewQueryDataResponse()
 
@@ -99,10 +94,6 @@ func (d *Datasource) query(_ context.Context, pCtx backend.PluginContext, query
 // datasource configuration page which allows users to verify that
 // a datasource is working as expected.
 func (d *Datasource) CheckHealth(_ context.Context, req *backend.CheckHealthRequest) (*backend.CheckHealthResult, error) {
-	// when logging at a non-Debug level, make sure you don't include sensitive information in the message
-	// (like the *backend.QueryDataRequest)
-	log.DefaultLogger.Debug("CheckHealth called")
-
 	var status = backend.HealthStatusOk
 	var message = "Data source is working"