@grafana/create-plugin 0.0.1

package/dist/utils/utils.files.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.isFileStartingWith = exports.removeFilesInCwd = exports.getOnlyNotExistingInCwd = exports.getOnlyExistingInCwd = exports.readJsonFile = exports.isFile = exports.filterOutCommonFiles = void 0;
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+var constants_1 = require("../constants");
+function filterOutCommonFiles(files, pluginType) {
+    var isFileCommonAndOverriden = function (file) {
+        return file.includes(constants_1.TEMPLATE_PATHS.common) &&
+            files.includes(file.replace(constants_1.TEMPLATE_PATHS.common, constants_1.TEMPLATE_PATHS[pluginType]));
+    };
+    return files.filter(function (file) { return (isFileCommonAndOverriden(file) ? false : true); });
+}
+exports.filterOutCommonFiles = filterOutCommonFiles;
+function isFile(path) {
+    try {
+        return fs_1["default"].lstatSync(path).isFile();
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isFile = isFile;
+function readJsonFile(filename) {
+    if (!isFile(filename)) {
+        throw new Error("There is no \"".concat(path_1["default"].basename(filename), "\" file found at \"").concat(filename, "\". Make sure you run this command from a plugins root directory."));
+    }
+    try {
+        return JSON.parse(fs_1["default"].readFileSync(filename).toString());
+    }
+    catch (error) {
+        error.message = "Cannot parse the \"".concat(path_1["default"].basename(filename), "\" file at ").concat(filename, ".");
+        throw error;
+    }
+}
+exports.readJsonFile = readJsonFile;
+function getOnlyExistingInCwd(files) {
+    return files.filter(function (file) { return fs_1["default"].existsSync(path_1["default"].join(process.cwd(), file)); });
+}
+exports.getOnlyExistingInCwd = getOnlyExistingInCwd;
+function getOnlyNotExistingInCwd(files) {
+    return files.filter(function (file) { return !fs_1["default"].existsSync(path_1["default"].join(process.cwd(), file)); });
+}
+exports.getOnlyNotExistingInCwd = getOnlyNotExistingInCwd;
+function removeFilesInCwd(files) {
+    for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
+        var file = files_1[_i];
+        fs_1["default"].rmSync(path_1["default"].join(process.cwd(), file), { recursive: true, force: true });
+    }
+}
+exports.removeFilesInCwd = removeFilesInCwd;
+function isFileStartingWith(file, filter) {
+    if (Array.isArray(filter)) {
+        return filter.some(function (f) { return file.startsWith(f); });
+    }
+    return file.startsWith(filter);
+}
+exports.isFileStartingWith = isFileStartingWith;

package/dist/utils/utils.handlebars.js

@@ -0,0 +1,73 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _this = this;
+exports.__esModule = true;
+exports.renderHandlebarsTemplate = exports.registerHandlebarsHelpers = exports.normalizeId = exports.ifEq = void 0;
+var handlebars_1 = __importDefault(require("handlebars"));
+var changeCase = __importStar(require("change-case"));
+var title_case_1 = __importDefault(require("title-case"));
+var upper_case_1 = __importDefault(require("upper-case"));
+var lower_case_1 = __importDefault(require("lower-case"));
+var ifEq = function (a, b, options) {
+    return a === b ? options.fn(_this) : options.inverse(_this);
+};
+exports.ifEq = ifEq;
+var normalizeId = function (pluginName, orgName, type) {
+    var re = new RegExp("-?".concat(type, "$"), 'i');
+    var newPluginName = pluginName.replace(re, '');
+    return changeCase.paramCase(orgName) + '-' + changeCase.paramCase(newPluginName) + "-".concat(type);
+};
+exports.normalizeId = normalizeId;
+function registerHandlebarsHelpers() {
+    var helpers = {
+        camelCase: changeCase.camelCase,
+        snakeCase: changeCase.snakeCase,
+        dotCase: changeCase.dotCase,
+        pathCase: changeCase.pathCase,
+        lowerCase: lower_case_1["default"],
+        upperCase: upper_case_1["default"],
+        sentenceCase: changeCase.sentenceCase,
+        constantCase: changeCase.constantCase,
+        titleCase: title_case_1["default"],
+        dashCase: changeCase.paramCase,
+        kabobCase: changeCase.paramCase,
+        kebabCase: changeCase.paramCase,
+        properCase: changeCase.pascalCase,
+        pascalCase: changeCase.pascalCase,
+        if_eq: exports.ifEq
+    };
+    Object.keys(helpers).forEach(function (helperName) {
+        return handlebars_1["default"].registerHelper(helperName, helpers[helperName]);
+    });
+}
+exports.registerHandlebarsHelpers = registerHandlebarsHelpers;
+function renderHandlebarsTemplate(template, data) {
+    registerHandlebarsHelpers();
+    return handlebars_1["default"].compile(template)(data);
+}
+exports.renderHandlebarsTemplate = renderHandlebarsTemplate;

package/dist/utils/utils.npm.js

@@ -0,0 +1,162 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.updateNpmScripts = exports.removeNpmDependencies = exports.getRemovableNpmDependencies = exports.getUpdatableNpmDependencies = exports.getPackageJsonUpdates = exports.updateNpmDependencies = exports.updatePackageJson = exports.hasNpmDependenciesToUpdate = exports.getPackageJsonUpdatesAsText = exports.getNpmDependencyUpdatesAsText = exports.writePackageJson = exports.getLatestPackageJson = exports.getPackageJson = void 0;
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+var semver_1 = __importDefault(require("semver"));
+var utils_files_1 = require("./utils.files");
+var utils_templates_1 = require("./utils.templates");
+var constants_1 = require("../constants");
+function getPackageJson() {
+    return (0, utils_files_1.readJsonFile)(path_1["default"].join(process.cwd(), 'package.json'));
+}
+exports.getPackageJson = getPackageJson;
+function getLatestPackageJson() {
+    var packageJsonPath = path_1["default"].join(constants_1.TEMPLATE_PATHS.common, 'package.json');
+    var data = (0, utils_templates_1.getTemplateData)();
+    return JSON.parse((0, utils_templates_1.renderTemplateFromFile)(packageJsonPath, data));
+}
+exports.getLatestPackageJson = getLatestPackageJson;
+function writePackageJson(json) {
+    return fs_1["default"].writeFileSync(path_1["default"].join(process.cwd(), 'package.json'), "".concat(JSON.stringify(json, null, 2), "\n"));
+}
+exports.writePackageJson = writePackageJson;
+function getNpmDependencyUpdatesAsText(dependencyUpdates) {
+    return Object.entries(dependencyUpdates)
+        .map(function (_a) {
+        var packageName = _a[0], _b = _a[1], prev = _b.prev, next = _b.next;
+        if (!prev) {
+            return "`".concat(packageName, "` - `").concat(next, "` (new)");
+        }
+        return "`".concat(packageName, "` - `").concat(prev, "` -> `").concat(next, "`");
+    })
+        .join('\n  ');
+}
+exports.getNpmDependencyUpdatesAsText = getNpmDependencyUpdatesAsText;
+function getPackageJsonUpdatesAsText(options) {
+    if (options === void 0) { options = {}; }
+    var asText = '';
+    var _a = getPackageJsonUpdates(options), dependencyUpdates = _a.dependencyUpdates, devDependencyUpdates = _a.devDependencyUpdates;
+    if (Object.keys(dependencyUpdates).length > 0) {
+        asText += "\n\n  **Dependencies**\n  ".concat(getNpmDependencyUpdatesAsText(dependencyUpdates));
+    }
+    if (Object.keys(devDependencyUpdates).length > 0) {
+        asText += "\n\n  **Dev Dependencies**\n  ".concat(getNpmDependencyUpdatesAsText(devDependencyUpdates));
+    }
+    return asText;
+}
+exports.getPackageJsonUpdatesAsText = getPackageJsonUpdatesAsText;
+function hasNpmDependenciesToUpdate(options) {
+    if (options === void 0) { options = {}; }
+    var _a = getPackageJsonUpdates(options), dependencyUpdates = _a.dependencyUpdates, devDependencyUpdates = _a.devDependencyUpdates;
+    return Object.keys(dependencyUpdates).length > 0 || Object.keys(devDependencyUpdates).length > 0;
+}
+exports.hasNpmDependenciesToUpdate = hasNpmDependenciesToUpdate;
+function updatePackageJson(options) {
+    if (options === void 0) { options = {}; }
+    var packageJson = getPackageJson();
+    var _a = getPackageJsonUpdates(options), dependencyUpdates = _a.dependencyUpdates, devDependencyUpdates = _a.devDependencyUpdates;
+    packageJson.dependencies = updateNpmDependencies(packageJson.dependencies, dependencyUpdates);
+    packageJson.devDependencies = updateNpmDependencies(packageJson.devDependencies, devDependencyUpdates);
+    writePackageJson(packageJson);
+}
+exports.updatePackageJson = updatePackageJson;
+function updateNpmDependencies(dependencies, updateSummary) {
+    var updatedDependencies = __assign({}, dependencies);
+    for (var _i = 0, _a = Object.entries(updateSummary); _i < _a.length; _i++) {
+        var _b = _a[_i], packageName = _b[0], summary = _b[1];
+        updatedDependencies[packageName] = summary.next;
+    }
+    return updatedDependencies;
+}
+exports.updateNpmDependencies = updateNpmDependencies;
+function getPackageJsonUpdates(options) {
+    if (options === void 0) { options = {}; }
+    var packageJson = getPackageJson();
+    var newPackageJson = getLatestPackageJson();
+    var dependencies = packageJson.dependencies || {};
+    var devDependencies = packageJson.devDependencies || {};
+    var newDependencies = newPackageJson.dependencies || {};
+    var newDevDependencies = newPackageJson.devDependencies || {};
+    var dependencyUpdates = getUpdatableNpmDependencies(dependencies, newDependencies, options);
+    var devDependencyUpdates = getUpdatableNpmDependencies(devDependencies, newDevDependencies, options);
+    return {
+        dependencyUpdates: dependencyUpdates,
+        devDependencyUpdates: devDependencyUpdates
+    };
+}
+exports.getPackageJsonUpdates = getPackageJsonUpdates;
+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 (!currentSemverRange) {
+            updateSummary[packageName] = { prev: null, next: newSemverRange };
+            continue;
+        }
+        if (newSemverRange === currentSemverRange) {
+            continue;
+        }
+        if (!semver_1["default"].validRange(newSemverRange) || !semver_1["default"].validRange(currentSemverRange)) {
+            updateSummary[packageName] = { prev: currentSemverRange, next: newSemverRange };
+            continue;
+        }
+        var newSemverVersion = semver_1["default"].minVersion(newSemverRange);
+        var currentSemverVersion = semver_1["default"].minVersion(currentSemverRange);
+        if (!newSemverVersion || !semver_1["default"].valid(newSemverVersion)) {
+            console.warn("Skipping: invalid new semver version \"".concat(newSemverRange, "\" for \"").concat(packageName, "\""));
+            continue;
+        }
+        if (!currentSemverVersion || !semver_1["default"].valid(currentSemverVersion)) {
+            console.warn("Skipping: invalid current semver version \"".concat(currentSemverRange, "\" for \"").concat(packageName, "\""));
+            continue;
+        }
+        if (!options.onlyOutdated || semver_1["default"].gte(newSemverVersion, currentSemverVersion)) {
+            updateSummary[packageName] = { prev: currentSemverRange, next: newSemverRange };
+            continue;
+        }
+    }
+    return updateSummary;
+}
+exports.getUpdatableNpmDependencies = getUpdatableNpmDependencies;
+function getRemovableNpmDependencies(packageNames) {
+    var _a = getPackageJson(), _b = _a.dependencies, dependencies = _b === void 0 ? {} : _b, _c = _a.devDependencies, devDependencies = _c === void 0 ? {} : _c;
+    return packageNames.filter(function (packageName) { return dependencies[packageName] || devDependencies[packageName]; });
+}
+exports.getRemovableNpmDependencies = getRemovableNpmDependencies;
+function removeNpmDependencies(packageNames, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.devOnly, devOnly = _c === void 0 ? false : _c;
+    var packageJson = getPackageJson();
+    for (var _i = 0, packageNames_1 = packageNames; _i < packageNames_1.length; _i++) {
+        var packageName = packageNames_1[_i];
+        if (!devOnly) {
+            delete packageJson.dependencies[packageName];
+        }
+        delete packageJson.devDependencies[packageName];
+    }
+    writePackageJson(packageJson);
+}
+exports.removeNpmDependencies = removeNpmDependencies;
+function updateNpmScripts() {
+    var packageJson = getPackageJson();
+    var latestPackageJson = getLatestPackageJson();
+    packageJson.scripts = __assign(__assign({}, packageJson.scripts), latestPackageJson.scripts);
+    writePackageJson(packageJson);
+}
+exports.updateNpmScripts = updateNpmScripts;

package/dist/utils/utils.plugin.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getPluginJson = void 0;
+var path_1 = __importDefault(require("path"));
+var utils_files_1 = require("./utils.files");
+function getPluginJson(srcDir) {
+    var srcPath = srcDir || path_1["default"].join(process.cwd(), 'src');
+    var pluginJsonPath = path_1["default"].join(srcPath, 'plugin.json');
+    return (0, utils_files_1.readJsonFile)(pluginJsonPath);
+}
+exports.getPluginJson = getPluginJson;

package/dist/utils/utils.templates.js

@@ -0,0 +1,77 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getTemplateData = exports.renderTemplateFromFile = exports.compileSingleTemplateFile = exports.compileTemplateFiles = exports.getProjectRelativeTemplatePath = exports.getTemplateFiles = void 0;
+var glob_1 = __importDefault(require("glob"));
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+var mkdirp_1 = __importDefault(require("mkdirp"));
+var utils_files_1 = require("./utils.files");
+var utils_handlebars_1 = require("./utils.handlebars");
+var utils_plugin_1 = require("./utils.plugin");
+var constants_1 = require("../constants");
+function getTemplateFiles(pluginType, filter) {
+    var commonFiles = glob_1["default"].sync("".concat(constants_1.TEMPLATE_PATHS.common, "/**"), { dot: true });
+    var pluginTypeSpecificFiles = glob_1["default"].sync("".concat(constants_1.TEMPLATE_PATHS[pluginType], "/**"), { dot: true });
+    var templateFiles = (0, utils_files_1.filterOutCommonFiles)(__spreadArray(__spreadArray([], commonFiles, true), pluginTypeSpecificFiles, true), pluginType);
+    if (filter) {
+        return templateFiles.filter(function (file) {
+            var projectRelativePath = getProjectRelativeTemplatePath(file, pluginType);
+            return (0, utils_files_1.isFileStartingWith)(projectRelativePath, filter);
+        });
+    }
+    return templateFiles;
+}
+exports.getTemplateFiles = getTemplateFiles;
+function getProjectRelativeTemplatePath(file, pluginType) {
+    return file.replace(constants_1.TEMPLATE_PATHS.common, '').replace(constants_1.TEMPLATE_PATHS[pluginType], '').replace(/^\/+/, '');
+}
+exports.getProjectRelativeTemplatePath = getProjectRelativeTemplatePath;
+function compileTemplateFiles(filter, data) {
+    var type = (0, utils_plugin_1.getPluginJson)().type;
+    getTemplateFiles(type, filter).forEach(function (file) { return compileSingleTemplateFile(type, file, data); });
+}
+exports.compileTemplateFiles = compileTemplateFiles;
+function compileSingleTemplateFile(pluginType, templateFile, data) {
+    if (!(0, utils_files_1.isFile)(templateFile)) {
+        return;
+    }
+    var rendered = renderTemplateFromFile(templateFile, data);
+    var relativeExportPath = templateFile.replace(constants_1.TEMPLATE_PATHS.common, '').replace(constants_1.TEMPLATE_PATHS[pluginType], '');
+    var exportPath = path_1["default"].join(constants_1.EXPORT_PATH_PREFIX, relativeExportPath);
+    mkdirp_1["default"].sync(path_1["default"].dirname(exportPath));
+    fs_1["default"].writeFileSync(exportPath, rendered);
+}
+exports.compileSingleTemplateFile = compileSingleTemplateFile;
+function renderTemplateFromFile(templateFile, data) {
+    return (0, utils_handlebars_1.renderHandlebarsTemplate)(fs_1["default"].readFileSync(templateFile).toString(), data);
+}
+exports.renderTemplateFromFile = renderTemplateFromFile;
+function getTemplateData() {
+    var _a, _b, _c;
+    var pluginJson = (0, utils_plugin_1.getPluginJson)();
+    return __assign(__assign({}, constants_1.EXTRA_TEMPLATE_VARIABLES), { pluginId: pluginJson.id, pluginName: pluginJson.name, pluginDescription: (_a = pluginJson.info) === null || _a === void 0 ? void 0 : _a.description, hasBackend: Boolean(pluginJson.backend), orgName: (_c = (_b = pluginJson.info) === null || _b === void 0 ? void 0 : _b.author) === null || _c === void 0 ? void 0 : _c.name, pluginType: pluginJson.type });
+}
+exports.getTemplateData = getTemplateData;

package/jest.config.js

@@ -0,0 +1,20 @@
+module.exports = {
+  testMatch: ['<rootDir>/src/**/*.{spec,test,jest}.{js,jsx,ts,tsx}'],
+  transform: {
+    '^.+\\.(t|j)sx?$': [
+      '@swc/jest',
+      {
+        sourceMaps: true,
+        jsc: {
+          parser: {
+            syntax: 'typescript',
+            tsx: true,
+            decorators: false,
+            dynamicImport: true,
+          },
+        },
+      },
+    ],
+  },
+  modulePathIgnorePatterns: ['<rootDir>/templates/'],
+};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@grafana/create-plugin",
+  "version": "0.0.1",
+  "main": "index.js",
+  "repository": "git@github.com:grafana/create-plugin.git",
+  "author": "Grafana",
+  "license": "MIT",
+  "bin": "./dist/bin/run.js",
+  "scripts": {
+    "clean": "rm -rf ./dist ./generated",
+    "clean-generated": "find ./generated -not -path \"./generated/node_modules*\" -not -path \"./generated\" -not -path \"./generated/yarn.lock\" -print0 | xargs -0  -I {} rm -rf {}",
+    "build": "yarn clean && tsc && chmod +x ./dist/bin/run.js",
+    "dev": "CREATE_PLUGIN_DEV=true nodemon --exec 'tsc'",
+    "dev-app": "CREATE_PLUGIN_DEV=true nodemon --exec 'yarn generate-app'",
+    "dev-panel": "CREATE_PLUGIN_DEV=true nodemon --exec 'yarn generate-panel'",
+    "dev-datasource": "CREATE_PLUGIN_DEV=true nodemon --exec 'yarn generate-datasource'",
+    "generate-app": "tsc && yarn clean-generated && CREATE_PLUGIN_DEV=true node ./dist/bin/run.js -- create-plugin 'Sample app' 'sample-org' 'This is a sample app.' 'app' 't' 't' 't'",
+    "generate-panel": "tsc && yarn clean-generated && CREATE_PLUGIN_DEV=true node ./dist/bin/run.js -- create-plugin 'Sample panel' 'sample-org' 'This is a sample panel.' 'panel' 't' 't' 't'",
+    "generate-datasource": "tsc && yarn clean-generated && CREATE_PLUGIN_DEV=true node ./dist/bin/run.js -- create-plugin 'Sample datasource' 'sample-org' 'This is a sample datasource.' 'datasource' 't' 't' 't'",
+    "lint": "eslint --cache --ignore-path ./.gitignore --ext .js,.jsx,.ts,.tsx ./src",
+    "lint:fix": "yarn lint --fix",
+    "test": "jest --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@grafana/tsconfig": "^1.2.0-rc1",
+    "@swc/core": "^1.2.162",
+    "@types/minimist": "^1.2.2",
+    "@types/mkdirp": "^1.0.2",
+    "@types/semver": "^7.3.9",
+    "enquirer": "^2.3.6",
+    "glob": "^7.1.7",
+    "jest": "^27.5.1",
+    "marked-terminal": "^5.1.1",
+    "marked": "^4.0.12",
+    "mkdirp": "^1.0.4",
+    "plop": "^2.7.4",
+    "semver": "^7.3.5"
+  },
+  "devDependencies": {
+    "@grafana/eslint-config": "^2.5.0",
+    "@swc/jest": "^0.2.20",
+    "@types/jest": "^27.4.1",
+    "@typescript-eslint/eslint-plugin": "^4.33.0",
+    "@typescript-eslint/parser": "^4.33.0",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-jsdoc": "^36.1.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-react": "^7.26.1",
+    "eslint-plugin-react-hooks": "^4.2.0",
+    "nodemon": "^2.0.13",
+    "tsc-watch": "^4.5.0",
+    "typescript": "^4.4.3"
+  },
+  "nodemonConfig": {
+    "watch": [
+      "src/**/*",
+      "templates/**/*"
+    ],
+    "ext": "*",
+    "events": {
+      "start": "cls || clear"
+    }
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}

package/src/bin/run.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+import minimist from 'minimist';
+import { generate, update, migrate } from '../commands';
+
+const args = process.argv.slice(2);
+const argv = minimist(args);
+const commands: Record<string, (argv: minimist.ParsedArgs) => void> = {
+  migrate,
+  generate,
+  update,
+};
+const command = commands[argv._[0]] || commands.generate;
+
+command(argv);

package/src/commands/generate.command.ts

@@ -0,0 +1,15 @@
+import path from 'path';
+import minimist from 'minimist';
+import { Plop, run } from 'plop';
+
+export const generate = async (argv: minimist.ParsedArgs) => {
+  Plop.launch(
+    {
+      cwd: argv.cwd,
+      configPath: path.join(__dirname, 'generate.plopfile.js'),
+      require: argv.require,
+      completion: argv.completion,
+    },
+    (env) => run(env, undefined, true)
+  );
+};

package/src/commands/generate.plopfile.ts

@@ -0,0 +1,151 @@
+import type { NodePlopAPI, ModifyActionConfig } from 'plop';
+import glob from 'glob';
+import path from 'path';
+import fs from 'fs';
+import { ifEq, normalizeId } from '../utils/utils.handlebars';
+import {
+  EXPORT_PATH_PREFIX,
+  IS_DEV,
+  TEMPLATE_PATHS,
+  PARTIALS_DIR,
+  PLUGIN_TYPES,
+  EXTRA_TEMPLATE_VARIABLES,
+} from '../constants';
+
+type CliArgs = {
+  pluginName: string;
+  pluginDescription: string;
+  orgName: string;
+  pluginType: string;
+  hasBackend: boolean;
+  hasGithubWorkflows: boolean;
+};
+
+// Plopfile API documentation: https://plopjs.com/documentation/#plopfile-api
+export default function (plop: NodePlopAPI) {
+  plop.setHelper('if_eq', ifEq);
+  plop.setHelper('normalize_id', normalizeId);
+
+  plop.setGenerator('create-plugin', {
+    description: 'used to scaffold a grafana plugin',
+    prompts: [
+      {
+        name: 'pluginName',
+        type: 'input',
+        message: 'What is going to be the name of your plugin?',
+      },
+      {
+        name: 'orgName',
+        type: 'input',
+        message: 'What is the organization name of your plugin?',
+        default: 'my-org',
+      },
+      {
+        name: 'pluginDescription',
+        type: 'input',
+        message: 'How would you describe your plugin?',
+        default: '<plugin description>',
+      },
+      {
+        name: 'pluginType',
+        type: 'list',
+        choices: [PLUGIN_TYPES.app, PLUGIN_TYPES.datasource, PLUGIN_TYPES.panel],
+        message: 'What kind of plugin would you like? ',
+      },
+      {
+        name: 'hasBackend',
+        type: 'confirm',
+        message: 'Do you want a backend part of your plugin?',
+        default: false,
+      },
+      {
+        name: 'hasGithubWorkflows',
+        type: 'confirm',
+        message: 'Do you want to add Github CI and Release workflows?',
+        default: false,
+      },
+      {
+        name: 'hasGithubLevitateWorkflow',
+        type: 'confirm',
+        message: 'Do you want to add a Github workflow for automatically checking "Grafana API compatibility" on PRs?',
+        default: false,
+      },
+    ],
+    // @ts-ignore - We would like to specify the Answers type correctly
+    actions: function ({ pluginType, hasBackend, hasGithubWorkflows, hasGithubLevitateWorkflow }: CliArgs) {
+      // Copy over files that are shared between plugins types
+      const commonActions = getActionsForTemplateFolder(TEMPLATE_PATHS.common);
+
+      // Copy over files from the plugin type specific folder, e.g. "tempaltes/app" for "app" plugins ("app" | "panel" | "datasource").
+      const pluginTypeSpecificActions = getActionsForTemplateFolder(TEMPLATE_PATHS[pluginType]);
+
+      // Copy over backend-specific files (if selected)
+      const backendActions = hasBackend ? getActionsForTemplateFolder(TEMPLATE_PATHS.backend) : [];
+
+      // Copy over Github workflow files (if selected)
+      const ciWorkflowActions = hasGithubWorkflows ? getActionsForTemplateFolder(TEMPLATE_PATHS.ciWorkflows) : [];
+
+      const isCompatibleWorkflowActions = hasGithubLevitateWorkflow
+        ? getActionsForTemplateFolder(TEMPLATE_PATHS.isCompatibleWorkflow)
+        : [];
+
+      // Replace conditional bits in the Readme files
+      const readmeActions = getActionsForReadme();
+
+      return [
+        ...commonActions,
+        ...pluginTypeSpecificActions,
+        ...backendActions,
+        ...ciWorkflowActions,
+        ...readmeActions,
+        ...isCompatibleWorkflowActions,
+      ];
+    },
+  });
+}
+
+function getActionsForReadme(): ModifyActionConfig[] {
+  return [
+    replacePatternWithTemplateInReadme('-- INSERT FRONTEND GETTING STARTED --', 'frontend-getting-started.md'),
+    replacePatternWithTemplateInReadme('-- INSERT BACKEND GETTING STARTED --', 'backend-getting-started.md'),
+  ];
+}
+
+function replacePatternWithTemplateInReadme(pattern: string, partialsFile: string): ModifyActionConfig {
+  return {
+    type: 'modify',
+    path: path.join(EXPORT_PATH_PREFIX, 'README.md'),
+    pattern,
+    // @ts-ignore
+    template: undefined,
+    templateFile: path.join(PARTIALS_DIR, partialsFile),
+    data: EXTRA_TEMPLATE_VARIABLES,
+  };
+}
+
+// TODO<use Plop action `addMany` instead>
+function getActionsForTemplateFolder(folderPath: string) {
+  const files = glob.sync(`${folderPath}/**`, { dot: true });
+  const getExportFileName = (f: string) => (path.extname(f) === '.hbs' ? path.basename(f, '.hbs') : path.basename(f));
+  const getExportPath = (f: string) => path.relative(folderPath, path.dirname(f));
+
+  return files.filter(isFile).map((f) => ({
+    type: 'add',
+    templateFile: f,
+    // The target path where the compiled template is saved to
+    path: path.join(EXPORT_PATH_PREFIX, getExportPath(f), getExportFileName(f)),
+    // We would like to override generated files in development mode
+    force: IS_DEV,
+    // We would still like to scaffold as many files as possible even if one fails
+    abortOnFail: false,
+    data: EXTRA_TEMPLATE_VARIABLES,
+  }));
+}
+
+function isFile(path: string) {
+  try {
+    return fs.lstatSync(path).isFile();
+  } catch (e) {
+    return false;
+  }
+}

package/src/commands/index.ts

@@ -0,0 +1,3 @@
+export * from './generate.command';
+export * from './update.command';
+export * from './migrate.command';