@grafana/create-plugin 5.17.0 → 5.18.0

package/dist/migrations/manager.test.js

@@ -0,0 +1,177 @@
+import { vi } from 'vitest';
+import { getMigrationsToRun, runMigration, runMigrations } from './manager.js';
+import migrationFixtures from './fixtures/migrations.js';
+import { Context } from './context.js';
+import { gitCommitNoVerify } from '../utils/utils.git.js';
+import { flushChanges, printChanges } from './utils.js';
+import { setRootConfig } from '../utils/utils.config.js';
+vi.mock('./utils.js', () => ({
+    flushChanges: vi.fn(),
+    printChanges: vi.fn(),
+    migrationsDebug: vi.fn(),
+}));
+vi.mock('../utils/utils.config.js', () => ({
+    setRootConfig: vi.fn(),
+}));
+vi.mock('../utils/utils.git.js', () => ({
+    gitCommitNoVerify: vi.fn(),
+}));
+describe('Migrations', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('getMigrationsToRun', () => {
+        it('should return the migrations that need to be run', () => {
+            const fromVersion = '3.0.0';
+            const toVersion = '5.0.0';
+            const migrations = getMigrationsToRun(fromVersion, toVersion, migrationFixtures.migrations);
+            expect(migrations).toEqual({
+                'migration-key1': {
+                    version: '5.0.0',
+                    description: 'Update project to use new cache directory',
+                    migrationScript: './5-0-0-cache-directory.js',
+                },
+            });
+            const fromVersion2 = '5.0.0';
+            const toVersion2 = '5.5.0';
+            const migrations2 = getMigrationsToRun(fromVersion2, toVersion2, migrationFixtures.migrations);
+            expect(migrations2).toEqual({
+                'migration-key1': {
+                    version: '5.0.0',
+                    description: 'Update project to use new cache directory',
+                    migrationScript: './5-0-0-cache-directory.js',
+                },
+                'migration-key2': {
+                    version: '5.4.0',
+                    description: 'Update project to use new cache directory',
+                    migrationScript: './5-4-0-cache-directory.js',
+                },
+            });
+            const fromVersion3 = '5.5.0';
+            const toVersion3 = '6.0.0';
+            const migrations3 = getMigrationsToRun(fromVersion3, toVersion3, migrationFixtures.migrations);
+            expect(migrations3).toEqual({
+                'migration-key3': {
+                    version: '6.0.0',
+                    description: 'Update project to use new cache directory',
+                    migrationScript: './5-4-0-cache-directory.js',
+                },
+            });
+        });
+        it('should sort migrations by version', () => {
+            const fromVersion = '2.0.0';
+            const toVersion = '6.0.0';
+            const migrations = getMigrationsToRun(fromVersion, toVersion, {
+                'migration-key1': {
+                    version: '5.3.0',
+                    description: 'Update project to use new cache directory',
+                    migrationScript: './5.3.0-migration.js',
+                },
+                'migration-key2': {
+                    version: '2.3.0',
+                    description: 'Update project to use new cache directory',
+                    migrationScript: './2.3.0-migration.js',
+                },
+                'migration-key3': {
+                    version: '2.0.0',
+                    description: 'Update project to use new cache directory',
+                    migrationScript: './2.0.0-migration.js',
+                },
+                'migration-key4': {
+                    version: '2.0.0',
+                    description: 'Update project to use new cache directory',
+                    migrationScript: './2.0.0-migration.js',
+                },
+            });
+            expect(Object.keys(migrations)).toEqual(['migration-key3', 'migration-key4', 'migration-key2', 'migration-key1']);
+        });
+    });
+    describe('runMigration', () => {
+        it('should pass a context to the migration script', async () => {
+            const mockContext = new Context('/virtual');
+            const migrationFn = vi.fn().mockResolvedValue(mockContext);
+            vi.doMock('./test-migration.js', () => ({
+                default: migrationFn,
+            }));
+            const migration = {
+                version: '1.0.0',
+                description: 'test migration',
+                migrationScript: './test-migration.js',
+            };
+            const result = await runMigration(migration, mockContext);
+            expect(migrationFn).toHaveBeenCalledWith(mockContext);
+            expect(result).toBe(mockContext);
+        });
+    });
+    describe('runMigrations', () => {
+        const migrationOneFn = vi.fn();
+        const migrationTwoFn = vi.fn();
+        const consoleMock = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        vi.doMock('./migration-one.js', () => ({
+            default: migrationOneFn,
+        }));
+        vi.doMock('./migration-two.js', () => ({
+            default: migrationTwoFn,
+        }));
+        const migrations = {
+            'migration-one': {
+                version: '1.0.0',
+                description: '...',
+                migrationScript: './migration-one.js',
+            },
+            'migration-two': {
+                version: '1.2.0',
+                description: '...',
+                migrationScript: './migration-two.js',
+            },
+        };
+        beforeEach(() => {
+            migrationOneFn.mockImplementation(async (context) => {
+                await context.addFile('one.ts', '');
+                return context;
+            });
+            migrationTwoFn.mockImplementation(async (context) => {
+                await context.addFile('two.ts', '');
+                return context;
+            });
+        });
+        afterAll(() => {
+            consoleMock.mockReset();
+        });
+        it('should flush the changes for each migration', async () => {
+            await runMigrations(migrations);
+            expect(flushChanges).toHaveBeenCalledTimes(2);
+        });
+        it('should print the changes for each migration', async () => {
+            await runMigrations(migrations);
+            expect(printChanges).toHaveBeenCalledTimes(2);
+        });
+        it('should not commit the changes for each migration by default', async () => {
+            await runMigrations(migrations);
+            expect(gitCommitNoVerify).toHaveBeenCalledTimes(0);
+        });
+        it('should commit the changes for each migration if the CLI arg is present', async () => {
+            await runMigrations(migrations, { commitEachMigration: true });
+            expect(gitCommitNoVerify).toHaveBeenCalledTimes(2);
+        });
+        it('should not create a commit for a migration that has no changes', async () => {
+            migrationTwoFn.mockImplementation(async (context) => context);
+            await runMigrations(migrations, { commitEachMigration: true });
+            expect(gitCommitNoVerify).toHaveBeenCalledTimes(1);
+        });
+        it('should update version in ".config/.cprc.json" on a successful update', async () => {
+            await runMigrations(migrations);
+            expect(setRootConfig).toHaveBeenCalledTimes(1);
+            expect(setRootConfig).toHaveBeenCalledWith({ version: '1.2.0' });
+        });
+        it('should NOT update version in ".config/.cprc.json" if any of the migrations fail', async () => {
+            migrationTwoFn.mockImplementation(async () => {
+                throw new Error('Unknown error.');
+            });
+            await expect(async () => {
+                await runMigrations(migrations);
+            }).rejects.toThrow();
+            expect(setRootConfig).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/migrations/migrations.js

@@ -0,0 +1,3 @@
+export default {
+    migrations: {},
+};

package/dist/migrations/migrations.test.js

@@ -0,0 +1,10 @@
+import defaultMigrations from './migrations.js';
+describe('migrations json', () => {
+    Object.entries(defaultMigrations.migrations).forEach(([key, migration]) => {
+        it(`should have a valid migration script path for ${key}`, () => {
+            expect(async () => {
+                await import(migration.migrationScript);
+            }).not.toThrow();
+        });
+    });
+});

package/dist/migrations/scripts/example-migration.js

@@ -0,0 +1,23 @@
+export default function migrate(context) {
+    const rawPkgJson = context.getFile('./package.json') ?? '{}';
+    const packageJson = JSON.parse(rawPkgJson);
+    if (packageJson.scripts && packageJson.scripts.build) {
+        const buildScript = packageJson.scripts.build;
+        const pattern = /(webpack.+-c\s.+\.ts)\s(.+)/;
+        if (pattern.test(buildScript) && !buildScript.includes('--profile')) {
+            packageJson.scripts.build = buildScript.replace(pattern, `$1 --profile $2`);
+        }
+        context.updateFile('./package.json', JSON.stringify(packageJson, null, 2));
+    }
+    if (context.doesFileExist('./src/README.md')) {
+        context.deleteFile('./src/README.md');
+    }
+    if (!context.doesFileExist('./src/foo.json')) {
+        context.addFile('./src/foo.json', JSON.stringify({ foo: 'bar' }));
+    }
+    if (context.doesFileExist('.eslintrc')) {
+        context.renameFile('.eslintrc', '.eslint.config.json');
+    }
+    context.readDir('./src');
+    return context;
+}

package/dist/migrations/scripts/example-migration.test.js

@@ -0,0 +1,24 @@
+import migrate from './example-migration.js';
+import { createDefaultContext } from '../test-utils.js';
+describe('Migration - append profile to webpack', () => {
+    test('should update the package.json', async () => {
+        const context = createDefaultContext();
+        context.updateFile('./package.json', JSON.stringify({
+            scripts: {
+                build: 'webpack -c ./.config/webpack/webpack.config.ts --env production',
+            },
+        }));
+        const updatedContext = await migrate(context);
+        expect(updatedContext.getFile('./package.json')).toMatch('webpack -c ./.config/webpack/webpack.config.ts --profile --env production');
+        expect(updatedContext.readDir('./src')).toEqual(['src/FOO.md', 'src/foo.json']);
+    });
+    it('should not make additional changes when run multiple times', async () => {
+        const context = await createDefaultContext();
+        await context.updateFile('./package.json', JSON.stringify({
+            scripts: {
+                build: 'webpack -c ./.config/webpack/webpack.config.ts --env production',
+            },
+        }));
+        await expect(migrate).toBeIdempotent(context);
+    });
+});

package/dist/migrations/test-utils.js

@@ -0,0 +1,9 @@
+import { Context } from './context.js';
+export function createDefaultContext() {
+    const context = new Context('/virtual');
+    context.addFile('.eslintrc', '{}');
+    context.addFile('./package.json', '{}');
+    context.addFile('./src/README.md', '');
+    context.addFile('./src/FOO.md', '');
+    return context;
+}

package/dist/migrations/utils.js

@@ -0,0 +1,46 @@
+import { dirname, join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { debug } from '../utils/utils.cli.js';
+import chalk from 'chalk';
+export function printChanges(context, key, migration) {
+    const changes = context.listChanges();
+    const lines = [];
+    for (const [filePath, { changeType }] of Object.entries(changes)) {
+        if (changeType === 'add') {
+            lines.push(`${chalk.green('ADD')} ${filePath}`);
+        }
+        else if (changeType === 'update') {
+            lines.push(`${chalk.yellow('UPDATE')} ${filePath}`);
+        }
+        else if (changeType === 'delete') {
+            lines.push(`${chalk.red('DELETE')} ${filePath}`);
+        }
+    }
+    console.log('--------------------------------');
+    console.log('Running migration:', key, chalk.bold(migration.migrationScript));
+    if (lines.length === 0) {
+        console.log('No changes were made');
+    }
+    else {
+        console.log(`${chalk.bold('Changes:')}\n  ${lines.join('\n  ')}`);
+    }
+    console.log('');
+}
+export function flushChanges(context) {
+    const basePath = context.basePath;
+    const changes = context.listChanges();
+    for (const [filePath, { changeType, content }] of Object.entries(changes)) {
+        const resolvedPath = join(basePath, filePath);
+        if (changeType === 'add') {
+            mkdirSync(dirname(resolvedPath), { recursive: true });
+            writeFileSync(resolvedPath, content);
+        }
+        else if (changeType === 'update') {
+            writeFileSync(resolvedPath, content);
+        }
+        else if (changeType === 'delete') {
+            rmSync(resolvedPath);
+        }
+    }
+}
+export const migrationsDebug = debug.extend('migrations');

package/dist/migrations/utils.test.js

@@ -0,0 +1,65 @@
+import { dirSync } from 'tmp';
+import { Context } from './context.js';
+import { flushChanges, printChanges } from './utils.js';
+import { join } from 'node:path';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+describe('utils', () => {
+    const tmpObj = dirSync({ unsafeCleanup: true });
+    const tmpDir = join(tmpObj.name, 'cp-test-migration');
+    beforeEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+        await mkdir(tmpDir, { recursive: true });
+        await writeFile(join(tmpDir, 'bar.ts'), 'content');
+        await writeFile(join(tmpDir, 'baz.ts'), 'content');
+    });
+    afterAll(() => {
+        tmpObj.removeCallback();
+    });
+    describe('flushChanges', () => {
+        it('should write files to disk', async () => {
+            const context = new Context(tmpDir);
+            await context.addFile('file.txt', 'content');
+            await context.addFile('deeper/path/to/file.txt', 'content');
+            flushChanges(context);
+            expect(readFileSync(join(tmpDir, 'file.txt'), 'utf-8')).toBe('content');
+            expect(readFileSync(join(tmpDir, 'deeper/path/to/file.txt'), 'utf-8')).toBe('content');
+        });
+        it('should update files on disk', async () => {
+            const context = new Context(tmpDir);
+            await context.updateFile('bar.ts', 'new content');
+            flushChanges(context);
+            expect(readFileSync(join(tmpDir, 'bar.ts'), 'utf-8')).toBe('new content');
+        });
+        it('should delete files from disk', async () => {
+            const context = new Context(tmpDir);
+            await context.deleteFile('bar.ts');
+            flushChanges(context);
+            expect(() => readFileSync(join(tmpDir, 'bar.ts'), 'utf-8')).toThrowError();
+        });
+    });
+    describe('printChanges', () => {
+        const originalConsoleLog = console.log;
+        beforeEach(() => {
+            vitest.spyOn(console, 'log').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            console.log = originalConsoleLog;
+        });
+        it('should print changes', async () => {
+            const context = new Context(tmpDir);
+            await context.addFile('file.txt', 'content');
+            await context.updateFile('baz.ts', 'new content');
+            await context.deleteFile('bar.ts');
+            printChanges(context, 'key', { migrationScript: 'test', description: 'test', version: '1.0.0' });
+            expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/ADD.+file\.txt/));
+            expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/UPDATE.+baz\.ts/));
+            expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/DELETE.+bar\.ts/));
+        });
+        it('should print no changes', async () => {
+            const context = new Context(tmpDir);
+            printChanges(context, 'key', { migrationScript: 'test', description: 'test', version: '1.0.0' });
+            expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/No changes were made/));
+        });
+    });
+});

package/dist/utils/utils.cli.js

@@ -1,4 +1,6 @@
 import minimist from 'minimist';
+import createDebug from 'debug';
+export const debug = createDebug('create-plugin');
 export const args = process.argv.slice(2);
 export const argv = minimist(args, {
     alias: {
@@ -7,6 +9,7 @@ export const argv = minimist(args, {
         hasBackend: 'backend',
         pluginName: 'plugin-name',
         orgName: 'org-name',
+        experimentalUpdates: 'experimental-updates',
     },
 });
 export const commandName = argv._[0] || 'generate';

package/dist/utils/utils.config.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import { writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { getVersion } from './utils.version.js';
 import { argv, commandName } from './utils.cli.js';
@@ -61,7 +62,7 @@ function readRCFileSync(path) {
     }
 }
 function createFeatureFlags(flags) {
-    const featureFlags = commandName === 'generate' ? DEFAULT_FEATURE_FLAGS : flags ?? {};
+    const featureFlags = commandName === 'generate' ? DEFAULT_FEATURE_FLAGS : (flags ?? {});
     const cliArgFlags = parseFeatureFlagsFromCliArgs();
     return { ...featureFlags, ...cliArgFlags };
 }
@@ -82,3 +83,10 @@ function parseFeatureFlagsFromCliArgs() {
         return { ...acc, [flag]: true };
     }, {});
 }
+export async function setRootConfig(configOverride = {}) {
+    const rootConfig = getRootConfig();
+    const rootConfigPath = path.resolve(process.cwd(), '.config/.cprc.json');
+    const updatedConfig = { ...rootConfig, ...configOverride };
+    await writeFile(rootConfigPath, JSON.stringify(updatedConfig, null, 2));
+    return updatedConfig;
+}

package/dist/utils/utils.console.js

@@ -7,6 +7,12 @@ const { prompt } = Enquirer;
 marked.use(markedTerminal({
     firstHeading: chalk.hex('#ff9900').underline.bold,
 }));
+export function printHeader(message, status = 'success') {
+    const color = status === 'success' ? 'green' : status === 'info' ? 'blue' : 'red';
+    let prefix = chalk.reset.inverse.bold[color](` CREATE PLUGIN `);
+    let txt = chalk[color](message);
+    console.log(`${prefix}  ${txt}`);
+}
 export function displayAsMarkdown(msg) {
     return marked(msg);
 }

package/dist/utils/utils.git.js

@@ -21,3 +21,16 @@ export async function isGitDirectoryClean() {
         return false;
     }
 }
+export async function gitCommitNoVerify(commitMsg) {
+    try {
+        let addAllCommand = 'git add -A';
+        let commitCommand = `git commit --no-verify -m ${commitMsg}`;
+        await exec(addAllCommand);
+        await exec(commitCommand);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Error committing changes:\n${error.message}`);
+        }
+    }
+}

package/dist/utils/utils.goSdk.js

@@ -1,9 +1,9 @@
 import which from 'which';
 import fs from 'node:fs';
-import createDebug from 'debug';
 import { exec } from 'node:child_process';
+import { debug } from './utils.cli.js';
 const SDK_GO_MODULE = 'github.com/grafana/grafana-plugin-sdk-go';
-const debug = createDebug('create-plugin:update-go');
+const updateGoDebugger = debug.extend('update-go');
 export async function updateGoSdkAndModules(exportPath) {
     const goModPath = `${exportPath}/go.mod`;
     if (!fs.existsSync(goModPath)) {
@@ -28,7 +28,7 @@ function updateSdk(exportPath) {
         const command = `go get ${SDK_GO_MODULE}`;
         exec(command, { cwd: exportPath }, (error) => {
             if (error) {
-                debug(error);
+                updateGoDebugger(error);
                 reject();
             }
             resolve();
@@ -40,7 +40,7 @@ function updateGoMod(exportPath) {
         const command = `go mod tidy`;
         exec(command, { cwd: exportPath }, (error) => {
             if (error) {
-                debug(error);
+                updateGoDebugger(error);
                 reject();
             }
             resolve();
@@ -52,7 +52,7 @@ function getLatestSdkVersion(exportPath) {
         const command = `go list -m -json ${SDK_GO_MODULE}@latest`;
         exec(command, { cwd: exportPath }, (error, stdout) => {
             if (error) {
-                debug(error);
+                updateGoDebugger(error);
                 reject();
             }
             try {
@@ -60,7 +60,7 @@ function getLatestSdkVersion(exportPath) {
                 resolve(version);
             }
             catch (e) {
-                debug(e);
+                updateGoDebugger(e);
                 reject();
             }
         });

package/dist/utils/utils.templates.js

@@ -2,16 +2,16 @@ import { lt as semverLt } from 'semver';
 import { glob } from 'glob';
 import path from 'node:path';
 import fs from 'node:fs';
-import createDebug from 'debug';
 import { filterOutCommonFiles, isFile, isFileStartingWith } from './utils.files.js';
 import { normalizeId, renderHandlebarsTemplate } from './utils.handlebars.js';
 import { getPluginJson } from './utils.plugin.js';
+import { debug } from './utils.cli.js';
 import { TEMPLATE_PATHS, EXPORT_PATH_PREFIX, EXTRA_TEMPLATE_VARIABLES, PLUGIN_TYPES, DEFAULT_FEATURE_FLAGS, } from '../constants.js';
 import { getPackageManagerInstallCmd, getPackageManagerWithFallback, getPackageManagerFromUserAgent, } from './utils.packageManager.js';
 import { getExportFileName } from '../utils/utils.files.js';
 import { getGrafanaRuntimeVersion, getVersion } from './utils.version.js';
 import { getConfig } from './utils.config.js';
-const debug = createDebug('create-plugin:templates');
+const templatesDebugger = debug.extend('templates');
 export function getTemplateFiles(pluginType, filter) {
     const commonFiles = glob.sync(`${TEMPLATE_PATHS.common}/**`, { dot: true });
     const pluginTypeSpecificFiles = glob.sync(`${TEMPLATE_PATHS[pluginType]}/**`, { dot: true });
@@ -112,6 +112,6 @@ export function getTemplateData(cliArgs) {
             pluginExecutable: pluginJson.executable,
         };
     }
-    debug('\nTemplate data:\n' + JSON.stringify(templateData, null, 2));
+    templatesDebugger('\nTemplate data:\n' + JSON.stringify(templateData, null, 2));
     return templateData;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grafana/create-plugin",
-  "version": "5.17.0",
+  "version": "5.18.0",
   "repository": {
     "directory": "packages/create-plugin",
     "url": "https://github.com/grafana/plugin-tools"
@@ -37,7 +37,7 @@
     "generate-datasource-backend": "tsc && npm run clean-generated && CREATE_PLUGIN_DEV=true node ./dist/bin/run.js --pluginName='Sample datasource' --orgName='sample-org' --pluginType='datasource' --hasBackend",
     "lint": "eslint --cache ./src",
     "lint:fix": "npm run lint -- --fix",
-    "test": "vitest",
+    "test": "vitest --passWithNoTests",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
@@ -61,9 +61,11 @@
     "@types/marked-terminal": "^6.1.1",
     "@types/minimist": "^1.2.5",
     "@types/semver": "^7.5.8",
+    "@types/tmp": "^0.2.6",
     "@types/which": "^3.0.4",
     "eslint-plugin-react": "^7.37.4",
-    "eslint-plugin-react-hooks": "^5.1.0"
+    "eslint-plugin-react-hooks": "^5.1.0",
+    "tmp": "^0.2.3"
   },
   "overrides": {
     "@types/marked-terminal": {
@@ -86,5 +88,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "cd30bf9b82e9571d5cfe73921b7e91feae54f77a"
+  "gitHead": "1e3f1321dea4acc946c9596f772d42c6ef7ac6c6"
 }