@grafana/create-plugin 6.3.0-canary.2319.19627830170.0 → 6.3.0-canary.2320.19632326797.0

package/src/codemods/additions/scripts/i18n/code-generation.ts

@@ -0,0 +1,156 @@
+import * as recast from 'recast';
+import * as babelParser from 'recast/parsers/babel-ts.js';
+
+import type { Context } from '../../../context.js';
+import { additionsDebug } from '../../../utils.js';
+
+const { builders } = recast.types;
+
+export function addI18nInitialization(context: Context, needsBackwardCompatibility: boolean): void {
+  // Find module.ts or module.tsx
+  const moduleTsPath = context.doesFileExist('src/module.ts')
+    ? 'src/module.ts'
+    : context.doesFileExist('src/module.tsx')
+      ? 'src/module.tsx'
+      : null;
+
+  if (!moduleTsPath) {
+    additionsDebug('No module.ts or module.tsx found, skipping i18n initialization');
+    return;
+  }
+
+  const moduleContent = context.getFile(moduleTsPath);
+  if (!moduleContent) {
+    return;
+  }
+
+  // Defensive: check if i18n is already initialized
+  if (moduleContent.includes('initPluginTranslations')) {
+    additionsDebug('i18n already initialized in module file');
+    return;
+  }
+
+  try {
+    const ast = recast.parse(moduleContent, {
+      parser: babelParser,
+    });
+
+    const imports = [];
+
+    // Add necessary imports based on backward compatibility
+    imports.push(
+      builders.importDeclaration(
+        [builders.importSpecifier(builders.identifier('initPluginTranslations'))],
+        builders.literal('@grafana/i18n')
+      )
+    );
+
+    imports.push(
+      builders.importDeclaration(
+        [builders.importDefaultSpecifier(builders.identifier('pluginJson'))],
+        builders.literal('plugin.json')
+      )
+    );
+
+    if (needsBackwardCompatibility) {
+      imports.push(
+        builders.importDeclaration(
+          [builders.importSpecifier(builders.identifier('config'))],
+          builders.literal('@grafana/runtime')
+        )
+      );
+      imports.push(
+        builders.importDeclaration(
+          [builders.importDefaultSpecifier(builders.identifier('semver'))],
+          builders.literal('semver')
+        )
+      );
+      imports.push(
+        builders.importDeclaration(
+          [builders.importSpecifier(builders.identifier('loadResources'))],
+          builders.literal('./loadResources')
+        )
+      );
+    }
+
+    // Add imports after the first import statement
+    const firstImportIndex = ast.program.body.findIndex((node: any) => node.type === 'ImportDeclaration');
+    if (firstImportIndex !== -1) {
+      ast.program.body.splice(firstImportIndex + 1, 0, ...imports);
+    } else {
+      ast.program.body.unshift(...imports);
+    }
+
+    // Add i18n initialization code
+    const i18nInitCode = needsBackwardCompatibility
+      ? `// Before Grafana version 12.1.0 the plugin is responsible for loading translation resources
+// In Grafana version 12.1.0 and later Grafana is responsible for loading translation resources
+const loaders = semver.lt(config?.buildInfo?.version, '12.1.0') ? [loadResources] : [];
+
+await initPluginTranslations(pluginJson.id, loaders);`
+      : `await initPluginTranslations(pluginJson.id);`;
+
+    // Parse the initialization code and insert it at the top level (after imports)
+    const initAst = recast.parse(i18nInitCode, {
+      parser: babelParser,
+    });
+
+    // Find the last import index
+    const lastImportIndex = ast.program.body.findLastIndex((node: any) => node.type === 'ImportDeclaration');
+    if (lastImportIndex !== -1) {
+      ast.program.body.splice(lastImportIndex + 1, 0, ...initAst.program.body);
+    } else {
+      ast.program.body.unshift(...initAst.program.body);
+    }
+
+    const output = recast.print(ast, {
+      tabWidth: 2,
+      trailingComma: true,
+      lineTerminator: '\n',
+    }).code;
+
+    context.updateFile(moduleTsPath, output);
+    additionsDebug(`Updated ${moduleTsPath} with i18n initialization`);
+  } catch (error) {
+    additionsDebug('Error updating module file:', error);
+  }
+}
+
+export function createLoadResourcesFile(context: Context): void {
+  const loadResourcesPath = 'src/loadResources.ts';
+
+  // Defensive: skip if already exists
+  if (context.doesFileExist(loadResourcesPath)) {
+    additionsDebug('loadResources.ts already exists, skipping');
+    return;
+  }
+
+  const pluginJsonRaw = context.getFile('src/plugin.json');
+  if (!pluginJsonRaw) {
+    additionsDebug('Cannot create loadResources.ts without plugin.json');
+    return;
+  }
+
+  const loadResourcesContent = `import { LANGUAGES, ResourceLoader, Resources } from '@grafana/i18n';
+import pluginJson from 'plugin.json';
+
+const resources = LANGUAGES.reduce<Record<string, () => Promise<{ default: Resources }>>>((acc, lang) => {
+  acc[lang.code] = async () => await import(\`./locales/\${lang.code}/\${pluginJson.id}.json\`);
+  return acc;
+}, {});
+
+export const loadResources: ResourceLoader = async (resolvedLanguage: string) => {
+  try {
+    const translation = await resources[resolvedLanguage]();
+    return translation.default;
+  } catch (error) {
+    // This makes sure that the plugin doesn't crash when the resolved language in Grafana isn't supported by the plugin
+    console.error(\`The plugin '\${pluginJson.id}' doesn't support the language '\${resolvedLanguage}'\`, error);
+    return {};
+  }
+};
+`;
+
+  context.addFile(loadResourcesPath, loadResourcesContent);
+  additionsDebug('Created src/loadResources.ts for backward compatibility');
+}

package/src/codemods/additions/scripts/i18n/config-updates.ts

@@ -0,0 +1,139 @@
+import { coerce, gte } from 'semver';
+import { parseDocument, stringify } from 'yaml';
+
+import type { Context } from '../../../context.js';
+import { additionsDebug } from '../../../utils.js';
+
+export function updateDockerCompose(context: Context): void {
+  if (!context.doesFileExist('docker-compose.yaml')) {
+    additionsDebug('docker-compose.yaml not found, skipping');
+    return;
+  }
+
+  const composeContent = context.getFile('docker-compose.yaml');
+  if (!composeContent) {
+    return;
+  }
+
+  try {
+    const composeDoc = parseDocument(composeContent);
+    const currentEnv = composeDoc.getIn(['services', 'grafana', 'environment']);
+
+    if (!currentEnv) {
+      additionsDebug('No environment section found in docker-compose.yaml, skipping');
+      return;
+    }
+
+    // Check if the feature toggle is already set
+    if (typeof currentEnv === 'object') {
+      const envMap = currentEnv as any;
+      const toggleValue = envMap.get('GF_FEATURE_TOGGLES_ENABLE');
+
+      if (toggleValue) {
+        const toggleStr = toggleValue.toString();
+        if (toggleStr.includes('localizationForPlugins')) {
+          additionsDebug('localizationForPlugins already in GF_FEATURE_TOGGLES_ENABLE');
+          return;
+        }
+        // Append to existing feature toggles
+        composeDoc.setIn(
+          ['services', 'grafana', 'environment', 'GF_FEATURE_TOGGLES_ENABLE'],
+          `${toggleStr},localizationForPlugins`
+        );
+      } else {
+        // Set new feature toggle
+        composeDoc.setIn(['services', 'grafana', 'environment', 'GF_FEATURE_TOGGLES_ENABLE'], 'localizationForPlugins');
+      }
+
+      context.updateFile('docker-compose.yaml', stringify(composeDoc));
+      additionsDebug('Updated docker-compose.yaml with localizationForPlugins feature toggle');
+    }
+  } catch (error) {
+    additionsDebug('Error updating docker-compose.yaml:', error);
+  }
+}
+
+export function updatePluginJson(context: Context, locales: string[], needsBackwardCompatibility: boolean): void {
+  if (!context.doesFileExist('src/plugin.json')) {
+    additionsDebug('src/plugin.json not found, skipping');
+    return;
+  }
+
+  const pluginJsonRaw = context.getFile('src/plugin.json');
+  if (!pluginJsonRaw) {
+    return;
+  }
+
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+
+    // Merge locales with existing languages (defensive: avoid duplicates)
+    const existingLanguages = Array.isArray(pluginJson.languages) ? pluginJson.languages : [];
+    const mergedLanguages = [...new Set([...existingLanguages, ...locales])];
+    pluginJson.languages = mergedLanguages;
+
+    // Update grafanaDependency based on backward compatibility needs
+    if (!pluginJson.dependencies) {
+      pluginJson.dependencies = {};
+    }
+
+    const currentGrafanaDep = pluginJson.dependencies.grafanaDependency || '>=11.0.0';
+    const targetVersion = needsBackwardCompatibility ? '11.0.0' : '12.1.0';
+    const minVersion = coerce(targetVersion);
+    const currentVersion = coerce(currentGrafanaDep.replace(/^[><=]+/, ''));
+
+    if (!currentVersion || !minVersion || !gte(currentVersion, minVersion)) {
+      pluginJson.dependencies.grafanaDependency = `>=${targetVersion}`;
+      additionsDebug(`Updated grafanaDependency to >=${targetVersion}`);
+    }
+
+    context.updateFile('src/plugin.json', JSON.stringify(pluginJson, null, 2));
+    additionsDebug('Updated src/plugin.json with languages:', locales);
+  } catch (error) {
+    additionsDebug('Error updating src/plugin.json:', error);
+  }
+}
+
+export function createI18nextConfig(context: Context): void {
+  // Defensive: skip if already exists
+  if (context.doesFileExist('i18next.config.ts')) {
+    additionsDebug('i18next.config.ts already exists, skipping');
+    return;
+  }
+
+  const pluginJsonRaw = context.getFile('src/plugin.json');
+  if (!pluginJsonRaw) {
+    additionsDebug('Cannot create i18next.config.ts without plugin.json');
+    return;
+  }
+
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+    const pluginId = pluginJson.id;
+
+    if (!pluginId) {
+      additionsDebug('No plugin ID found in plugin.json');
+      return;
+    }
+
+    const i18nextConfig = `import { defineConfig } from 'i18next-cli';
+import pluginJson from './src/plugin.json';
+
+export default defineConfig({
+  locales: pluginJson.languages,
+  extract: {
+    input: ['src/**/*.{tsx,ts}'],
+    output: 'src/locales/{{language}}/{{namespace}}.json',
+    defaultNS: pluginJson.id,
+    functions: ['t', '*.t'],
+    transComponents: ['Trans'],
+  },
+});
+`;
+
+    context.addFile('i18next.config.ts', i18nextConfig);
+    additionsDebug('Created i18next.config.ts');
+  } catch (error) {
+    additionsDebug('Error creating i18next.config.ts:', error);
+  }
+}