opensource/grafana
1
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-08-01 08:33:00 +08:00
Code Issues Packages Projects Releases Wiki Activity

Toolkit: Remove deprecated package:build, node-version-check and toolkit:build commands (#67475)

Browse Source
This commit is contained in:
Esteban Beltran
2023-04-28 10:53:23 +02:00
committed by GitHub
parent 82838a2176
commit 0ec40a51eb
7 changed files with 11 additions and 339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
packages/grafana-toolkit/src/cli/index.ts
View File

@ -1,65 +1,21 @@
import chalk from 'chalk';
import { program } from 'commander';
import { nodeVersionCheckerTask } from './tasks/nodeVersionChecker';
import { buildPackageTask } from './tasks/package.build';
import { pluginBuildTask } from './tasks/plugin.build';
import { getToolkitVersion } from './tasks/plugin.utils';
import { templateTask } from './tasks/template';
import { toolkitBuildTask } from './tasks/toolkit.build';
import { execTask } from './utils/execTask';
export const run = (includeInternalScripts = false) => {
if (includeInternalScripts) {
program.option('-d, --depreciate <scripts>', 'Inform about npm script deprecation', (v) => v.split(','));
program
.command('package:build')
.option('-s, --scope <packages>', 'packages=[data|runtime|ui|toolkit|e2e|e2e-selectors]')
.description('Builds @grafana/* package to packages/grafana-*/dist')
.action(async (cmd) => {
console.warn(
'@grafana/toolkit package:build task is deprecated and will be removed in @grafana/toolkit@10.0.0.'
);
await execTask(buildPackageTask)({
scope: cmd.scope,
});
});
program
.command('node-version-check')
.description('[deprecated] Verify node version')
.action(async () => {
console.log(
chalk.yellow.bold(
`⚠️ This command is deprecated and will be removed in v10. No further support will be provided. ⚠️`
)
);
console.log(
'if you were reliant on this command we recommend https://www.npmjs.com/package/check-node-version'
);
await execTask(nodeVersionCheckerTask)({});
});
program
.command('debug:template')
.description('Just testing')
.action(async (cmd) => {
await execTask(templateTask)({});
});
program
.command('toolkit:build')
.description('[Deprecated] Prepares grafana/toolkit dist package')
.action(async (cmd) => {
console.log(
chalk.yellow.bold(
`⚠️ This command is deprecated and will be removed in v10. No further support will be provided. ⚠️`
)
);
await execTask(toolkitBuildTask)({});
});
}
program.option('-v, --version', 'Toolkit version').action(async () => {

77
packages/grafana-toolkit/src/cli/tasks/nodeVersionChecker.ts
View File

@ -1,77 +0,0 @@
import chalk from 'chalk';
import { readFileSync } from 'fs';
import { coerce, satisfies } from 'semver';
import { Task, TaskRunner } from './task';
interface FailedVersionCheck {
file: string;
line: string;
}
interface NodeVersionCheckerOptions {}
const pattern = /(circleci\/|FROM )node\:([0-9]+(\.[0-9]+){0,2})/gm;
const packageJsonFile = 'package.json';
const failures: FailedVersionCheck[] = [];
export const nodeVersionFiles = [packageJsonFile, 'Dockerfile'];
const nodeVersionCheckerRunner: TaskRunner<NodeVersionCheckerOptions> = async () => {
// Read version from package json and treat that as the expected version in all other locations
const packageJson = require(`${process.cwd()}/${packageJsonFile}`);
const expectedVersion = packageJson.engines.node;
console.log(chalk.yellow(`Specified node version in package.json is: ${expectedVersion}`));
for (const file of nodeVersionFiles) {
const fileContent = readFileSync(`${process.cwd()}/${file}`);
const matches = fileContent.toString('utf8').match(pattern);
if (!matches) {
continue;
}
for (const match of matches) {
const actualVersion = coerce(match);
if (!actualVersion) {
failures.push({
file,
line: match,
});
continue;
}
const satisfied = satisfies(actualVersion, expectedVersion);
if (!satisfied) {
failures.push({
file,
line: match,
});
}
}
}
if (failures.length > 0) {
console.log(chalk.red('--------------------------------------------------------------------'));
console.log(chalk.red(`These entries don't satisfy the engine version in ${packageJsonFile}`));
console.log(chalk.red('--------------------------------------------------------------------'));
for (let index = 0; index < failures.length; index++) {
const failure = failures[index];
console.log(chalk.green(`\tIn ${failure.file} the line ${failure.line} does not satisfy ${expectedVersion}.`));
}
throw new Error('Node versions not in sync');
}
console.log(chalk.yellow('--------------------------------------------------------------------'));
console.log(chalk.yellow('All node versions seem ok.'));
console.log(chalk.yellow('--------------------------------------------------------------------'));
};
export const nodeVersionCheckerTask = new Task<NodeVersionCheckerOptions>(
'Node Version Checker',
nodeVersionCheckerRunner
);

92
packages/grafana-toolkit/src/cli/tasks/package.build.ts
View File

@ -1,92 +0,0 @@
import chalk from 'chalk';
import execa = require('execa');
import { promises as fs } from 'fs';
import globby from 'globby';
import { cloneDeep } from 'lodash';
import * as path from 'path';
import { useSpinner } from '../utils/useSpinner';
import { Task, TaskRunner } from './task';
const clean = (cwd: string) => useSpinner('Cleaning', () => execa('npm', ['run', 'clean'], { cwd }));
const compile = (cwd: string) =>
useSpinner('Compiling sources', () => execa('tsc', ['-p', './tsconfig.build.json'], { cwd }));
const bundle = (cwd: string) => useSpinner('Bundling', () => execa('npm', ['run', 'bundle'], { cwd }));
const preparePackage = async (packageDist: string, pkg: any) => {
pkg = cloneDeep(pkg); // avoid mutations
pkg.main = 'index.js';
pkg.types = 'index.d.ts';
const version: string = pkg.version;
const name: string = pkg.name;
const deps: any = pkg.dependencies;
// Below we are adding cross-dependencies to Grafana's packages
// with the version being published
if (name.endsWith('/ui')) {
deps['@grafana/data'] = version;
} else if (name.endsWith('/runtime')) {
deps['@grafana/data'] = version;
deps['@grafana/ui'] = version;
} else if (name.endsWith('/toolkit')) {
deps['@grafana/data'] = version;
deps['@grafana/ui'] = version;
}
await useSpinner('Updating package.json', () =>
fs.writeFile(`${packageDist}/package.json`, JSON.stringify(pkg, null, 2))
);
};
const moveFiles = (fromPath: string, toPath: string) => {
const files = ['README.md', 'CHANGELOG.md', 'index.js'];
return useSpinner(`Moving ${files.join(', ')} files`, () => {
const promises = files.map((file) => fs.copyFile(`${fromPath}/${file}`, `${toPath}/${file}`));
return Promise.all(promises);
});
};
const moveStaticFiles = async (packageRoot: string, pkg: any) => {
if (pkg.name.endsWith('/ui')) {
return useSpinner('Moving static files', async () => {
const staticFiles = await globby(`${packageRoot}/src/**/*.{png,svg,gif,jpg}`);
const pathSearch = new RegExp(`^${packageRoot}/src`);
const pathReplace = `${packageRoot}/compiled`;
const promises = staticFiles.map((file) => fs.copyFile(file, file.replace(pathSearch, pathReplace)));
await Promise.all(promises);
});
}
};
interface PackageBuildOptions {
scope: string;
}
const buildTaskRunner: TaskRunner<PackageBuildOptions> = async ({ scope }) => {
if (!scope) {
throw new Error('Provide packages with -s, --scope <packages>');
}
const scopes = scope.split(',').map(async (s) => {
const packageRoot = path.resolve(__dirname, `../../../../grafana-${s}`);
const packageDist = `${packageRoot}/dist`;
const pkg = require(`${packageRoot}/package.json`);
console.log(chalk.yellow(`Building ${pkg.name} (package.json version: ${pkg.version})`));
await clean(packageRoot);
await compile(packageRoot);
await moveStaticFiles(packageRoot, pkg);
await bundle(packageRoot);
await preparePackage(packageDist, pkg);
await moveFiles(packageRoot, packageDist);
});
await Promise.all(scopes);
};
export const buildPackageTask = new Task<PackageBuildOptions>('Package build', buildTaskRunner);

99
packages/grafana-toolkit/src/cli/tasks/toolkit.build.ts
View File

@ -1,99 +0,0 @@
import chalk from 'chalk';
import execa = require('execa');
import * as fs from 'fs';
import { useSpinner } from '../utils/useSpinner';
import { Task, TaskRunner } from './task';
const path = require('path');
let distDir: string, cwd: string;
const clean = () => useSpinner('Cleaning', () => execa('npm', ['run', 'clean']));
const compile = () =>
useSpinner('Compiling sources', async () => {
try {
await execa('tsc', ['-p', './tsconfig.json']);
} catch (e) {
console.log(e);
throw e;
}
});
const copyFiles = () => {
const files = [
'src/config/prettier.plugin.config.json',
'src/config/prettier.plugin.rc.js',
'src/config/tsconfig.plugin.json',
'src/config/tsconfig.plugin.local.json',
'src/config/eslint.plugin.js',
'src/config/styles.mock.js',
'src/config/jest.babel.config.js',
'src/config/jest.plugin.config.local.js',
'src/config/matchMedia.js',
'src/config/react-inlinesvg.tsx',
];
return useSpinner(`Moving ${files.join(', ')} files`, async () => {
const promises = files.map((file) => {
return new Promise<void>((resolve, reject) => {
const basedir = path.dirname(`${distDir}/${file}`);
if (!fs.existsSync(basedir)) {
fs.mkdirSync(basedir, { recursive: true });
}
fs.copyFile(`${cwd}/${file}`, `${distDir}/${file}`, (err) => {
if (err) {
reject(err);
return;
}
resolve();
});
});
});
await Promise.all(promises);
});
};
const copySassFiles = () => {
const files = ['_variables.generated.scss', '_variables.dark.generated.scss', '_variables.light.generated.scss'];
const exportDir = `${cwd}/sass`;
return useSpinner(`Copy scss files ${files.join(', ')} files`, async () => {
const sassDir = path.resolve(cwd, '../../public/sass/');
if (!fs.existsSync(exportDir)) {
fs.mkdirSync(exportDir);
}
const promises = files.map((file) => {
return new Promise<void>((resolve, reject) => {
const name = file.replace('.generated', '');
fs.copyFile(`${sassDir}/${file}`, `${exportDir}/${name}`, (err) => {
if (err) {
reject(err);
return;
}
resolve();
});
});
});
await Promise.all(promises);
});
};
interface ToolkitBuildOptions {}
const toolkitBuildTaskRunner: TaskRunner<ToolkitBuildOptions> = async () => {
cwd = path.resolve(__dirname, '../../../');
distDir = `${cwd}/dist`;
const pkg = require(`${cwd}/package.json`);
console.log(chalk.yellow(`Building ${pkg.name} (package.json version: ${pkg.version})`));
await clean();
await compile();
await copyFiles();
await copySassFiles();
};
export const toolkitBuildTask = new Task<ToolkitBuildOptions>('@grafana/toolkit build', toolkitBuildTaskRunner);