Merge pull request #3 from fingerprintjs/feat/platform-specific-run-inter-1194

Add platform-specific run support with legacy compatibility

Related-Task: INTER-1194

Author: erayaydin

README.md

@@ -5,9 +5,9 @@
 
 ## Overview
 
-This plugin retrieves native dependency version information from iOS and Android projects and integrates it into the semantic release workflow generate notes steps.
+This plugin retrieves native dependency version information from iOS and/or Android projects and integrates it into the semantic release workflow generate notes steps.
 
-- Extracts dependency versions from podspec json file (iOS) and Gradle task output (Android)
+- Extracts dependency versions from podspec json file (iOS) and/or Gradle task output (Android)
 - Ensures version consistency in release notes
 - Automates version retrieval for better release documentation
 
@@ -28,25 +28,27 @@ Add the plugin to your `.releaserc` configuration:
     [
       "@fingerprintjs/semantic-release-native-dependency-plugin",
       {
-        "iOS": {
-          "podSpecJsonPath": "RNFingerprintjsPro.podspec.json",
-          "dependencyName": "FingerprintPro",
-          "displayName": "Fingerprint iOS SDK"
-        },
-        "android": {
-          "path": "android",
-          "gradleTaskName": "printFingerprintNativeSDKVersion",
-          "displayName": "Fingerprint Android SDK"
+        "platforms": {
+          "iOS": {
+            "podSpecJsonPath": "RNFingerprintjsPro.podspec.json",
+            "dependencyName": "FingerprintPro",
+            "displayName": "Fingerprint iOS SDK"
+          },
+          "android": {
+            "path": "android",
+            "gradleTaskName": "printFingerprintNativeSDKVersion",
+            "displayName": "Fingerprint Android SDK"
+          }
         }
       }
-    ],
+    ]
   ]
 }
 ```
 
 ## How It Works
 
-- The plugin reads version information from podspec json file (iOS) and a custom Gradle task output (Android).
+- The plugin reads version information from podspec json file (iOS) and/or a custom Gradle task output (Android).
 - It automatically includes the extracted versions in the release notes.
 - Helps maintain transparency about dependency versions used in each release.
 

src/@types/pluginConfig.ts

@@ -1,12 +1,15 @@
+import { AndroidPlatformConfiguration } from '../platforms/android'
+import { IOSPlatformConfiguration } from '../platforms/iOS'
+
+export interface PlatformConfig {
+  iOS?: IOSPlatformConfiguration
+  android?: AndroidPlatformConfiguration
+}
+
 export default interface PluginConfig {
-  iOS: {
-    podSpecJsonPath: string
-    dependencyName: string | undefined
-    displayName: string | undefined
-  }
-  android: {
-    path: string
-    gradleTaskName: string | undefined
-    displayName: string | undefined
-  }
+  platforms: PlatformConfig
+  /** @deprecated Use `platforms.iOS` instead */
+  iOS?: IOSPlatformConfiguration
+  /** @deprecated Use `platforms.android` instead */
+  android?: AndroidPlatformConfiguration
 }

src/generateNotes.ts

@@ -1,148 +1,49 @@
-import { join } from 'node:path'
 import type { GenerateNotesContext } from 'semantic-release'
-import { spawn } from 'node:child_process'
-import type { Signale } from 'signale'
-import PluginConfig from './@types/pluginConfig'
-import { getCommand } from './gradle'
-import { humanizeMavenStyleVersionRange } from './utils'
-import { readFileSync } from 'node:fs'
-
-export async function getAndroidVersion(
-  cwd: string,
-  androidPath: string,
-  androidGradleTaskName: string,
-  env: NodeJS.ProcessEnv,
-  logger: Signale
-): Promise<string> {
-  const androidFullPath = join(cwd, androidPath)
-  const command = await getCommand(androidFullPath)
-
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, [androidGradleTaskName, '-q', '--console=plain'], {
-      cwd: androidPath,
-      env,
-      detached: true,
-      stdio: ['inherit', 'pipe', 'pipe'],
-    })
-    if (child.stdout === null) {
-      reject(new Error('Unexpected error: stdout of subprocess is null'))
-      return
+import PluginConfig, { PlatformConfig } from './@types/pluginConfig'
+import { resolve as androidResolve } from './platforms/android'
+import { resolve as iOSResolve } from './platforms/iOS'
+
+const generateNotes = async (config: PluginConfig, ctx: GenerateNotesContext) => {
+  const platformVersions: { [key in keyof PlatformConfig]?: string } = {}
+
+  // Normalize plugin config: prefer `platforms`, fall back to legacy top-level platform keys for backward compatibility
+  // TODO: Remove support for top-level `android` and `iOS` keys in the next major release (BC)
+  const platforms: PlatformConfig = config.platforms || {}
+  if (!config.platforms) {
+    if (config.android) {
+      ctx.logger.warn('[DEPRECATED] Use `platforms.android` instead of top-level `android` in plugin config.')
+      platforms.android = config.android
     }
-    if (child.stderr === null) {
-      reject(new Error('Unexpected error: stderr of subprocess is null'))
-      return
-    }
-
-    let androidVersion: string | null = null
-    child.stdout.on('data', (line: Buffer) => {
-      if (!line || line.toString().trim() === '') {
-        return
-      }
-
-      logger.debug(`Gradle stdout: ${line}`)
-      androidVersion = line.toString().trim()
-    })
-    child.stderr.on('data', (line: Buffer) => {
-      logger.error(line.toString().trim())
-    })
-    child.on('close', (code: number) => {
-      if (code !== 0) {
-        reject(new Error(`Unexpected error: Gradle failed with status code ${code}`))
-        return
-      }
-
-      if (androidVersion === null) {
-        reject(new Error(`Could not read output of \`${androidGradleTaskName}\` gradle task.`))
-        return
-      }
-
-      resolve(androidVersion)
-    })
-    child.on('error', (err) => {
-      logger.error(err)
-      reject(err)
-    })
-  })
-}
-
-type PodspecJson = {
-  dependencies: {
-    [key: string]: [string]
-  }
-}
-
-export const getIOSVersion = async (cwd: string, iOSPodSpecJsonPath: string, dependencyName: string) => {
-  const jsonFile = join(cwd, iOSPodSpecJsonPath)
 
-  let fileContent: string
-  try {
-    fileContent = readFileSync(jsonFile, 'utf8')
-  } catch (error: any) {
-    switch (error.code) {
-      case 'ENOENT':
-        throw new Error(`${iOSPodSpecJsonPath} file does not exist.`)
-      case 'EACCES':
-        throw new Error(`${iOSPodSpecJsonPath} file cannot be accessed.`)
-      default:
-        throw new Error(`${iOSPodSpecJsonPath} file cannot be read.`)
+    if (config.iOS) {
+      ctx.logger.warn('[DEPRECATED] Use `platforms.iOS` instead of top-level `iOS` in plugin config.')
+      platforms.iOS = config.iOS
     }
   }
 
-  let data: PodspecJson
-  try {
-    data = JSON.parse(fileContent) as PodspecJson
-  } catch (error) {
-    throw new Error(`${iOSPodSpecJsonPath} file cannot be parsed as JSON.`)
+  if (!platforms.android && !platforms.iOS) {
+    throw new Error('No platforms specified. You must configure at least one platform under `platforms`.')
   }
 
-  if (!data.dependencies || !data.dependencies[dependencyName]) {
-    throw new Error(`${iOSPodSpecJsonPath} file does not contain '${dependencyName}' in dependencies.`)
+  if (platforms.android) {
+    const androidVersion = await androidResolve(ctx, platforms.android)
+    platformVersions.android = androidVersion
+    ctx.logger.log(`Detected Android Version: \`${androidVersion}\``)
   }
 
-  return data.dependencies[dependencyName].join(' and ')
-}
-
-const generateNotes = async ({ iOS, android }: PluginConfig, { logger, cwd, env }: GenerateNotesContext) => {
-  if (!cwd) {
-    throw new Error(`Current working directory is required to detect native dependency versions.`)
-  }
-
-  if (!android.gradleTaskName) {
-    throw new Error('Android gradle task name should be defined.')
-  }
-
-  if (!iOS.podSpecJsonPath) {
-    throw new Error('iOS Podspec Json path should be defined.')
-  }
-
-  if (!iOS.dependencyName) {
-    throw new Error('iOS Dependency name should be defined.')
+  if (platforms.iOS) {
+    const iOSVersion = await iOSResolve(ctx, platforms.iOS)
+    platformVersions.iOS = iOSVersion
+    ctx.logger.log(`Detected iOS Version: \`${iOSVersion}\``)
   }
 
-  if (!android.displayName) {
-    android.displayName = 'Android Dependency'
-  }
-
-  if (!iOS.displayName) {
-    iOS.displayName = 'iOS Dependency'
-  }
-
-  const androidVersion = await getAndroidVersion(
-    cwd,
-    android.path,
-    android.gradleTaskName,
-    env as NodeJS.ProcessEnv,
-    logger
-  )
-  const humanizedAndroidVersion = humanizeMavenStyleVersionRange(androidVersion)
-  logger.log(`Detected ${android.displayName} Version: \`${androidVersion}\` \`${humanizedAndroidVersion}\``)
-
-  const iosVersion = await getIOSVersion(cwd, iOS.podSpecJsonPath, iOS.dependencyName)
-  logger.log(`Detected ${iOS.displayName} Version: \`${iosVersion}\``)
-
-  return `${android.displayName} Version Range: **\`${humanizedAndroidVersion}\`**
-
-${iOS.displayName} Version Range: **\`${iosVersion}\`**`
+  return Object.keys(platformVersions)
+    .map((platformKey) => {
+      const platform = platformKey as keyof PlatformConfig
+      const version = platformVersions[platform]
+      return `${platforms[platform]?.displayName ?? platform} Version Range: **\`${version}\`**`
+    })
+    .join('\n\n')
 }
 
 export default generateNotes

src/platforms/android.ts

@@ -0,0 +1,92 @@
+import { humanizeMavenStyleVersionRange } from '../utils'
+import type { GenerateNotesContext } from 'semantic-release'
+import type { Signale } from 'signale'
+import { join } from 'node:path'
+import { getCommand } from '../gradle'
+import { spawn } from 'node:child_process'
+
+export interface AndroidPlatformConfiguration {
+  path: string | undefined
+  gradleTaskName: string | undefined
+  displayName: string | undefined
+}
+
+async function runGradleTask(
+  cwd: string,
+  androidPath: string,
+  androidGradleTaskName: string,
+  env: NodeJS.ProcessEnv,
+  logger: Signale
+): Promise<string> {
+  const androidFullPath = join(cwd, androidPath)
+  const command = await getCommand(androidFullPath)
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, [androidGradleTaskName, '-q', '--console=plain'], {
+      cwd: androidPath,
+      env,
+      detached: true,
+      stdio: ['inherit', 'pipe', 'pipe'],
+    })
+    if (child.stdout === null) {
+      reject(new Error('Unexpected error: stdout of subprocess is null'))
+      return
+    }
+    if (child.stderr === null) {
+      reject(new Error('Unexpected error: stderr of subprocess is null'))
+      return
+    }
+
+    let androidVersion: string | null = null
+    child.stdout.on('data', (line: Buffer) => {
+      if (!line || line.toString().trim() === '') {
+        return
+      }
+
+      logger.debug(`Gradle stdout: ${line}`)
+      androidVersion = line.toString().trim()
+    })
+    child.stderr.on('data', (line: Buffer) => {
+      logger.error(line.toString().trim())
+    })
+    child.on('close', (code: number) => {
+      if (code !== 0) {
+        reject(new Error(`Unexpected error: Gradle failed with status code ${code}`))
+        return
+      }
+
+      if (androidVersion === null) {
+        reject(new Error(`Could not read output of \`${androidGradleTaskName}\` gradle task.`))
+        return
+      }
+
+      resolve(androidVersion)
+    })
+    child.on('error', (err) => {
+      logger.error(err)
+      reject(err)
+    })
+  })
+}
+
+export type AndroidResolveContext = Pick<GenerateNotesContext, 'logger' | 'cwd' | 'env'>
+
+export const resolve = async (
+  { logger, cwd, env }: AndroidResolveContext,
+  { path, gradleTaskName }: AndroidPlatformConfiguration
+) => {
+  if (!cwd) {
+    throw new Error(`Current working directory is required to detect android dependency version range.`)
+  }
+
+  if (!path) {
+    throw new Error('Android path should be defined.')
+  }
+
+  if (!gradleTaskName) {
+    throw new Error('Android gradle task name should be defined.')
+  }
+
+  const androidVersion = await runGradleTask(cwd, path, gradleTaskName, env as NodeJS.ProcessEnv, logger)
+  return humanizeMavenStyleVersionRange(androidVersion)
+}