refactor: internal plugins (#329)

* refactor: internal plugins

* add missing file

* changeset

* revert

* fix test

Author: thymikee

.changeset/unlucky-bikes-think.md

@@ -0,0 +1,6 @@
+---
+'@rnef/config': patch
+'@rnef/cli': patch
+---
+
+refactor: internal plugins

packages/cli/src/lib/cli.ts

@@ -4,9 +4,9 @@ import { fileURLToPath } from 'node:url';
 import { type CommandType, getConfig } from '@rnef/config';
 import { color, logger, resolveFilenameUp, RnefError } from '@rnef/tools';
 import { Command } from 'commander';
-import { logConfig } from '../config.js';
 import { checkDeprecatedOptions } from './checkDeprecatedOptions.js';
-import { nativeFingerprintCommand } from './commands/fingerprint.js';
+import { fingerprintPlugin } from './plugins/fingerprint.js';
+import { logConfigPlugin } from './plugins/logConfig.js';
 
 const require = createRequire(import.meta.url);
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -31,22 +31,9 @@ export const cli = async ({ cwd, argv }: CliOptions) => {
     .option('--verbose', 'enable verbose logging')
     .version(version);
 
+  const internalPlugins = [logConfigPlugin, fingerprintPlugin];
   // Register commands from the config
-  const config = await getConfig(cwd);
-
-  program
-    .command('config')
-    .option('-p, --platform <string>', 'Select platform, e.g. ios or android')
-    .action((args) => logConfig(args, config));
-
-  program
-    .command('fingerprint [path]')
-    .option('-p, --platform <string>', 'Select platform, e.g. ios or android')
-    .option('--raw', 'Output the raw fingerprint hash for piping')
-    .action(async (path, options) => {
-      const fingerprintOptions = config.getFingerprintOptions();
-      await nativeFingerprintCommand(path, fingerprintOptions, options);
-    });
+  const config = await getConfig(cwd, internalPlugins);
 
   ensureUniqueCommands(config.commands);
 

packages/cli/src/lib/commands/fingerprint.ts

@@ -0,0 +1,103 @@
+import { performance } from 'node:perf_hooks';
+import type { PluginApi } from '@rnef/config';
+import {
+  intro,
+  isInteractive,
+  logger,
+  nativeFingerprint,
+  outro,
+  RnefError,
+  spinner,
+} from '@rnef/tools';
+
+type NativeFingerprintCommandOptions = {
+  platform: 'ios' | 'android';
+  raw?: boolean;
+};
+
+type ConfigFingerprintOptions = {
+  extraSources: string[];
+  ignorePaths: string[];
+};
+
+export async function nativeFingerprintCommand(
+  path = '.',
+  { extraSources, ignorePaths }: ConfigFingerprintOptions,
+  options: NativeFingerprintCommandOptions
+) {
+  validateOptions(options);
+  const platform = options.platform;
+  const readablePlatformName = platform === 'ios' ? 'iOS' : 'Android';
+
+  if (options?.raw || !isInteractive()) {
+    const fingerprint = await nativeFingerprint(path, {
+      platform,
+      extraSources,
+      ignorePaths,
+    });
+    console.log(fingerprint.hash);
+    return;
+  }
+
+  intro(`${readablePlatformName} Fingerprint`);
+
+  const loader = spinner();
+  loader.start("Calculating fingerprint for the project's native parts");
+
+  const start = performance.now();
+  const fingerprint = await nativeFingerprint(path, {
+    platform,
+    extraSources,
+    ignorePaths,
+  });
+  const duration = performance.now() - start;
+
+  loader.stop(`Fingerprint calculated: ${fingerprint.hash}`);
+
+  logger.debug('Sources:', JSON.stringify(fingerprint.sources, null, 2));
+  logger.debug(`Duration: ${(duration / 1000).toFixed(1)}s`);
+
+  outro('Success 🎉.');
+}
+
+function validateOptions(options: NativeFingerprintCommandOptions) {
+  if (!options.platform) {
+    throw new RnefError(
+      'The --platform flag is required. Please specify either "ios" or "android".'
+    );
+  }
+  if (options.platform !== 'ios' && options.platform !== 'android') {
+    throw new RnefError(
+      `Unsupported platform "${options.platform}". Please specify either "ios" or "android".`
+    );
+  }
+}
+
+export const fingerprintPlugin = () => (api: PluginApi) => {
+  api.registerCommand({
+    name: 'fingerprint',
+    description: 'Calculate fingerprint for given platform',
+    action: async (path, options) => {
+      const fingerprintOptions = api.getFingerprintOptions();
+      await nativeFingerprintCommand(path, fingerprintOptions, options);
+    },
+    options: [
+      {
+        name: '-p, --platform <string>',
+        description: 'Select platform, e.g. ios or android',
+      },
+      {
+        name: '--raw',
+        description: 'Output the raw fingerprint hash for piping',
+      },
+    ],
+    args: [
+      { name: '[path]', description: 'Directory to calculate fingerprint for' },
+    ],
+  });
+
+  return {
+    name: 'internal_fingerprint',
+    description: 'Fingerprint plugin',
+  };
+};

packages/cli/src/lib/plugins/fingerprint.ts

@@ -2,7 +2,7 @@ import type {
   Config,
   DependencyConfig,
 } from '@react-native-community/cli-types';
-import type { ConfigOutput } from '@rnef/config';
+import type { ConfigOutput, PluginApi } from '@rnef/config';
 
 function isValidRNDependency(config: DependencyConfig) {
   return (
@@ -28,7 +28,10 @@ function filterConfig(config: Config) {
 
 export const logConfig = async (
   args: { platform?: string },
-  ownConfig: ConfigOutput
+  ownConfig: {
+    platforms: ConfigOutput['platforms'];
+    root: ConfigOutput['root'];
+  }
 ) => {
   const { loadConfigAsync } = await import(
     '@react-native-community/cli-config'
@@ -49,3 +52,29 @@ export const logConfig = async (
 
   console.log(JSON.stringify(filterConfig(config), null, 2));
 };
+
+export const logConfigPlugin =
+  (ownConfig: {
+    platforms: ConfigOutput['platforms'];
+    root: ConfigOutput['root'];
+  }) =>
+  (api: PluginApi) => {
+    api.registerCommand({
+      name: 'config',
+      description: 'Output autolinking config',
+      action: async (args) => {
+        await logConfig(args, ownConfig);
+      },
+      options: [
+        {
+          name: '-p, --platform <string>',
+          description: 'Select platform, e.g. ios or android',
+        },
+      ],
+    });
+
+    return {
+      name: 'internal_config',
+      description: 'Configuration plugin',
+    };
+  };

packages/cli/src/config.ts renamed to packages/cli/src/lib/plugins/logConfig.ts

@@ -27,7 +27,7 @@ test.each([['.js'], ['.mjs'], ['.ts']])(
   plugins: [],
 }`,
     });
-    const config = await getConfig(DIR);
+    const config = await getConfig(DIR, []);
     expect(config).toMatchObject({ commands: [] });
   }
 );
@@ -52,7 +52,7 @@ module.exports = {
 };
 `,
   });
-  const config = await getConfig(DIR);
+  const config = await getConfig(DIR, []);
   expect(config).toMatchObject({
     commands: [
       {
@@ -67,15 +67,11 @@ module.exports = {
 test('should load plugin that registers a command', async () => {
   const __dirname = dirname(fileURLToPath(import.meta.url));
   const config = await getConfig(
-    join(__dirname, './__fixtures__/config-with-sample-plugin')
+    join(__dirname, './__fixtures__/config-with-sample-plugin'),
+    []
   );
   expect(config).toMatchObject({
     commands: [
-      {
-        action: expect.any(Function),
-        description: 'Test command',
-        name: 'test-command',
-      },
       {
         action: expect.any(Function),
         description: 'Build android',
@@ -108,6 +104,11 @@ test('should load plugin that registers a command', async () => {
           },
         ],
       },
+      {
+        action: expect.any(Function),
+        description: 'Test command',
+        name: 'test-command',
+      },
     ],
   });
 });

packages/config/src/lib/__tests__/config.test.ts

@@ -117,7 +117,15 @@ const importUp = async (
   return importUp(parentDir, name);
 };
 
-export async function getConfig(dir: string): Promise<ConfigOutput> {
+export async function getConfig(
+  dir: string,
+  internalPlugins: Array<
+    (ownConfig: {
+      platforms: ConfigOutput['platforms'];
+      root: ConfigOutput['root'];
+    }) => PluginType
+  >
+): Promise<ConfigOutput> {
   const { config, filePathWithExt, configDir } = await importUp(
     dir,
     'rnef.config'
@@ -167,13 +175,6 @@ export async function getConfig(dir: string): Promise<ConfigOutput> {
       },
   };
 
-  if (validatedConfig.plugins) {
-    // plugins register commands
-    for (const plugin of validatedConfig.plugins) {
-      assignOriginToCommand(plugin, api, validatedConfig);
-    }
-  }
-
   const platforms: Record<string, PlatformOutput> = {};
   if (validatedConfig.platforms) {
     // platforms register commands and custom platform functionality (TBD)
@@ -183,10 +184,25 @@ export async function getConfig(dir: string): Promise<ConfigOutput> {
     }
   }
 
+  if (validatedConfig.plugins) {
+    // plugins register commands
+    for (const plugin of validatedConfig.plugins) {
+      assignOriginToCommand(plugin, api, validatedConfig);
+    }
+  }
+
   if (validatedConfig.bundler) {
     assignOriginToCommand(validatedConfig.bundler, api, validatedConfig);
   }
 
+  for (const internalPlugin of internalPlugins) {
+    assignOriginToCommand(
+      internalPlugin({ root: projectRoot, platforms }),
+      api,
+      validatedConfig
+    );
+  }
+
   const outputConfig: ConfigOutput = {
     root: projectRoot,
     commands: validatedConfig.commands ?? [],