customerio-expo-plugin 3.3.0 → 3.5.0

package/plugin/src/postInstallHelper.js

@@ -1,32 +1,90 @@
 const fs = require('fs');
+const path = require('path');
+
+const RN_SDK_PACKAGE = 'customerio-reactnative';
+
+// Locate customerio-reactnative/package.json from a postinstall context.
+//
+// `INIT_CWD` is set by npm, pnpm, and yarn during lifecycle scripts to point
+// at the consumer's project root. That makes it the most reliable starting
+// point — the plugin's own __dirname can be deep inside `.pnpm/...` under pnpm.
+//
+// We probe `${INIT_CWD}/node_modules/customerio-reactnative/package.json` first
+// so we agree with the symlinked layout React Native autolinking expects, then
+// fall back to resolve-from from the consumer root, then to the legacy
+// __dirname-relative walk-up for environments where INIT_CWD is missing.
+function findRNSDKPackageJson() {
+  const candidates = [];
+
+  if (process.env.INIT_CWD) {
+    candidates.push(
+      path.join(process.env.INIT_CWD, 'node_modules', RN_SDK_PACKAGE, 'package.json')
+    );
+  }
+
+  // Legacy flat-npm layout fallback: plugin lives at
+  // <consumer>/node_modules/customerio-expo-plugin/plugin/src and the SDK at
+  // <consumer>/node_modules/customerio-reactnative.
+  candidates.push(path.join(__dirname, '..', '..', '..', RN_SDK_PACKAGE, 'package.json'));
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  // Final fallback: resolve-from from INIT_CWD. This walks up node_modules
+  // and handles yarn classic workspaces where the dep is hoisted.
+  if (process.env.INIT_CWD) {
+    try {
+      const resolveFrom = require('resolve-from');
+      const resolved = resolveFrom.silent(
+        process.env.INIT_CWD,
+        `${RN_SDK_PACKAGE}/package.json`
+      );
+      if (resolved) return resolved;
+    } catch (_) {
+      // resolve-from missing or unable to resolve — fall through to null.
+    }
+  }
+
+  return null;
+}
 
 function runPostInstall() {
-  // react native SDK package.json path
-  const reactNativePackageJsonFile = `${__dirname}/../../../customerio-reactnative/package.json`;
-  const expoPackageJsonFile = `${__dirname}/../../package.json`;
+  const expoPackageJsonFile = path.join(__dirname, '..', '..', 'package.json');
+
   try {
-    // if react native SDK is installed
-    if (fs.existsSync(reactNativePackageJsonFile)) {
-      const reactNativePackageJson = fs.readFileSync(
-        reactNativePackageJsonFile,
-        'utf8'
-      );
-      const expoPackageJson = require(expoPackageJsonFile);
+    const reactNativePackageJsonFile = findRNSDKPackageJson();
+    if (!reactNativePackageJsonFile) {
+      // Not necessarily an error: the plugin may be installed without the RN
+      // SDK (e.g., during a tooling-only install). The prebuild-time write
+      // covers the common case anyway.
+      return;
+    }
 
-      const reactNativePackage = JSON.parse(reactNativePackageJson);
-      reactNativePackage.expoVersion = expoPackageJson.version;
+    const expoPackageJson = require(expoPackageJsonFile);
+    const reactNativePackage = JSON.parse(
+      fs.readFileSync(reactNativePackageJsonFile, 'utf8')
+    );
 
-      fs.writeFileSync(
-        reactNativePackageJsonFile,
-        JSON.stringify(reactNativePackage, null, 2)
-      );
+    if (reactNativePackage.expoVersion === expoPackageJson.version) {
+      return;
     }
+
+    reactNativePackage.expoVersion = expoPackageJson.version;
+    fs.writeFileSync(
+      reactNativePackageJsonFile,
+      JSON.stringify(reactNativePackage, null, 2)
+    );
   } catch (error) {
     console.warn(
-      'Unable to find customerio-reactnative package.json file. Please make sure you have installed the customerio-reactnative package.',
+      'customerio-expo-plugin postinstall: failed to write expoVersion into customerio-reactnative/package.json. ' +
+        'The expo prebuild step will retry this. Original error:',
       error
     );
   }
 }
 
 exports.runPostInstall = runPostInstall;
+exports.findRNSDKPackageJson = findRNSDKPackageJson;

package/plugin/src/utils/resolveRNSDK.ts

@@ -0,0 +1,118 @@
+import fs from 'fs';
+import path from 'path';
+
+const RN_SDK_PACKAGE = 'customerio-reactnative';
+const REACT_NATIVE_PACKAGE = 'react-native';
+
+export type ResolvedRNSDK = {
+  // Absolute path to the package directory.
+  packageDir: string;
+  // Absolute path to package.json inside that directory.
+  packageJsonPath: string;
+};
+
+// Reads the installed react-native package's version starting from `fromDir`.
+// Used to decide which autolinking flavor will resolve customerio-reactnative
+// at pod install time, so our :path agrees with what autolinking emits:
+//   - RN <0.80 ships @react-native-community/cli, which uses a lexical
+//     resolution (no realpath following).
+//   - RN >=0.80 routes pod autolinking through expo-modules-autolinking,
+//     which realpaths.
+// Returns null if react-native cannot be located or its package.json cannot
+// be read; callers should default to the modern (realpath) behavior in that
+// case since it has been the working path for the last several Expo SDKs.
+export function tryReadRNVersion(fromDir: string): string | null {
+  try {
+    const direct = path.join(
+      fromDir,
+      'node_modules',
+      REACT_NATIVE_PACKAGE,
+      'package.json'
+    );
+    if (fs.existsSync(direct)) {
+      return readVersion(direct);
+    }
+    const resolveFrom = require('resolve-from');
+    const fallback = resolveFrom.silent(
+      fromDir,
+      `${REACT_NATIVE_PACKAGE}/package.json`
+    );
+    if (fallback) {
+      return readVersion(fallback);
+    }
+  } catch {
+    // Fall through to null.
+  }
+  return null;
+}
+
+function readVersion(pkgJsonPath: string): string | null {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+    return typeof pkg.version === 'string' ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+
+// Resolves the customerio-reactnative SDK location starting from `fromDir`.
+//
+// Probe-then-fallback so the result agrees with React Native autolinking
+// across npm flat, pnpm, and yarn-workspace layouts:
+//   1. `fromDir/node_modules/customerio-reactnative/package.json` — preferred.
+//      Works for npm flat, pnpm (the symlinked path; we never realpath it),
+//      and yarn workspaces with leaf node_modules. Matches what RN
+//      autolinking emits for its pod entry, so CocoaPods sees one
+//      consistent :path.
+//   2. `resolve-from` walking up from `fromDir` — only used when (1) misses.
+//      Handles yarn classic workspaces where the dep is hoisted to a parent
+//      node_modules. yarn classic has no symlinks, so the realpath is fine.
+//
+// Returns null if neither finds the package, including the case where
+// `resolve-from` itself can't be required (mirrors tryReadRNVersion's
+// graceful-failure shape so callers can rely on the documented contract).
+export function tryResolveRNSDK(fromDir: string): ResolvedRNSDK | null {
+  try {
+    const directPkgJson = path.join(
+      fromDir,
+      'node_modules',
+      RN_SDK_PACKAGE,
+      'package.json'
+    );
+    if (fs.existsSync(directPkgJson)) {
+      return {
+        packageDir: path.dirname(directPkgJson),
+        packageJsonPath: directPkgJson,
+      };
+    }
+
+    const resolveFrom = require('resolve-from');
+    const fallbackPkgJson = resolveFrom.silent(
+      fromDir,
+      `${RN_SDK_PACKAGE}/package.json`
+    );
+    if (fallbackPkgJson) {
+      return {
+        packageDir: path.dirname(fallbackPkgJson),
+        packageJsonPath: fallbackPkgJson,
+      };
+    }
+  } catch {
+    // Fall through to null. resolveRNSDK() turns this into a clear
+    // "customerio-reactnative was not found" error for the caller.
+  }
+
+  return null;
+}
+
+// Same as tryResolveRNSDK but throws a clear error when the package is missing.
+export function resolveRNSDK(fromDir: string): ResolvedRNSDK {
+  const resolved = tryResolveRNSDK(fromDir);
+  if (!resolved) {
+    throw new Error(
+      `${RN_SDK_PACKAGE} was not found relative to ${fromDir}. ` +
+      `Ensure it is installed in your project (or in a parent workspace's node_modules).`
+    );
+  }
+  return resolved;
+}

package/plugin/src/utils/writeExpoVersion.ts

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import type { ConfigPlugin } from '@expo/config-plugins';
+
+import { logger } from './logger';
+import { getPluginVersion } from './plugin';
+import { tryResolveRNSDK } from './resolveRNSDK';
+
+// Writes the plugin's version into customerio-reactnative/package.json under
+// the `expoVersion` key. The RN SDK reads this at runtime (customerio-cdp.ts)
+// to set its User-Agent `packageSource` to "Expo" instead of "ReactNative".
+//
+// We rely on the postinstall hook (postInstallHelper.js) for the same write
+// at install time, but call this from the plugin entry as a fallback for
+// installs where postinstall does not run cleanly — most notably pnpm
+// monorepos and any CI that uses --ignore-scripts.
+//
+// The write is idempotent: we no-op when the value is already correct.
+export function writeExpoVersion(projectRoot: string): void {
+  let resolved;
+  try {
+    resolved = tryResolveRNSDK(projectRoot);
+  } catch (error) {
+    logger.warn(
+      `Could not locate customerio-reactnative to write expoVersion. ` +
+      `User-Agent attribution may be incorrect. Original error: ${error}`
+    );
+    return;
+  }
+
+  if (!resolved) {
+    return;
+  }
+
+  try {
+    const pluginVersion = getPluginVersion();
+    const pkg = JSON.parse(fs.readFileSync(resolved.packageJsonPath, 'utf8'));
+    if (pkg.expoVersion === pluginVersion) {
+      return;
+    }
+    pkg.expoVersion = pluginVersion;
+    fs.writeFileSync(
+      resolved.packageJsonPath,
+      JSON.stringify(pkg, null, 2)
+    );
+  } catch (error) {
+    logger.warn(
+      `Failed to write expoVersion into ${resolved.packageJsonPath}. ` +
+      `User-Agent attribution may be incorrect. Original error: ${error}`
+    );
+  }
+}
+
+export const withExpoVersion: ConfigPlugin = (config) => {
+  // _internal.projectRoot is set by Expo when running through prebuild;
+  // fall back to process.cwd() for any path that calls the plugin in
+  // a non-prebuild context.
+  const projectRoot =
+    (config as unknown as { _internal?: { projectRoot?: string } })._internal?.projectRoot ||
+    process.cwd();
+  writeExpoVersion(projectRoot);
+  return config;
+};