customerio-expo-plugin 3.3.0 → 3.4.0

package/plugin/src/helpers/constants/ios.ts

@@ -1,18 +1,97 @@
+import fs from 'fs';
+import * as semver from 'semver';
+
 const path = require('path');
-const resolveFrom = require('resolve-from');
+import { resolveRNSDK, tryReadRNVersion } from '../../utils/resolveRNSDK';
+
+// Threshold at which React Native pod autolinking moves from
+// @react-native-community/cli (lexical, symlink-preserving) to
+// expo-modules-autolinking (realpath). The two flavors emit different
+// :path strings on pnpm/yarn-symlink layouts, so to keep CocoaPods happy
+// we must match whichever flavor will resolve the same package later.
+const RN_REALPATH_AUTOLINKING_MIN_VERSION = '0.80.0';
+
+const PLUGIN_LOG_PREFIX = '[CustomerIO Plugin]';
+
+// Always-on so the trail shows up in customer-shared `expo prebuild`
+// output without needing a separate verbose-mode opt-in.
+function pluginLog(message: string): void {
+  // eslint-disable-next-line no-console
+  console.log(`${PLUGIN_LOG_PREFIX} ${message}`);
+}
 
+/**
+ * Returns the relative path from the iOS project dir to the installed
+ * customerio-reactnative directory, in the exact form React Native pod
+ * autolinking will emit for the same package. The two autolinking
+ * flavors disagree on path shape under pnpm/yarn symlinks:
+ *
+ *   - RN <0.80 (`@react-native-community/cli`): walks node_modules
+ *     lexically, preserves symlinks. We keep the symlink path too —
+ *     `tryResolveRNSDK` already does this without calling realpath.
+ *
+ *   - RN >=0.80 (`expo-modules-autolinking`): realpaths the package
+ *     via Node, emitting the underlying `.pnpm/...` (or yarn-classic)
+ *     path. We match by realpath'ing the resolved directory.
+ *
+ * Decision points are logged so a customer's prebuild output is enough
+ * to triage path-resolution issues without a follow-up "set
+ * CUSTOMERIO_DEBUG_MODE and rerun" round-trip.
+ */
 export function getRelativePathToRNSDK(iosPath: string) {
-  // Root path of the Expo project
   const rootAppPath = path.dirname(iosPath);
+  pluginLog(
+    `Resolving customerio-reactnative for Podfile (iosPath=${iosPath}, projectRoot=${rootAppPath})`
+  );
+
+  const { packageDir } = resolveRNSDK(rootAppPath);
+  pluginLog(`customerio-reactnative resolved to: ${packageDir}`);
 
-  // Path of the cio RN package.json file. Example: test-app/node_modules/customerio-reactnative/package.json
-  const pluginPackageJsonPath = resolveFrom.silent(
-    rootAppPath,
-    `customerio-reactnative/package.json`
+  const rnVersion = tryReadRNVersion(rootAppPath);
+  pluginLog(`Detected react-native version: ${rnVersion ?? 'unknown'}`);
+
+  const useLexical = shouldUseLexicalPath(rnVersion);
+  pluginLog(
+    useLexical
+      ? `RN <${RN_REALPATH_AUTOLINKING_MIN_VERSION} — using lexical/symlink path to match @react-native-community/cli autolinking`
+      : `RN >=${RN_REALPATH_AUTOLINKING_MIN_VERSION} or unknown — using realpath to match expo-modules-autolinking`
   );
 
-  // Example: ../node_modules/customerio-reactnative
-  return path.relative(iosPath, path.dirname(pluginPackageJsonPath));
+  let absolutePath: string;
+  if (useLexical) {
+    absolutePath = packageDir;
+  } else {
+    try {
+      absolutePath = fs.realpathSync(packageDir);
+      if (absolutePath !== packageDir) {
+        pluginLog(`Realpath differs from resolved dir: ${absolutePath}`);
+      }
+    } catch (err) {
+      pluginLog(
+        `realpathSync failed (${
+          err instanceof Error ? err.message : String(err)
+        }); falling back to symlink path`
+      );
+      absolutePath = packageDir;
+    }
+  }
+
+  const relativePath = path.relative(iosPath, absolutePath);
+  pluginLog(`Final Podfile :path => '${relativePath}'`);
+  return relativePath;
+}
+
+function shouldUseLexicalPath(rnVersion: string | null): boolean {
+  if (!rnVersion) {
+    // Modern Expo (realpath) has been the working path for the last few
+    // SDKs, so it's the safer default when RN can't be detected.
+    return false;
+  }
+  const coerced = semver.valid(rnVersion) || semver.coerce(rnVersion);
+  if (!coerced) {
+    return false;
+  }
+  return semver.lt(coerced, RN_REALPATH_AUTOLINKING_MIN_VERSION);
 }
 
 export const IOS_DEPLOYMENT_TARGET = '13.0';

package/plugin/src/helpers/utils/injectCIOPodfileCode.ts

@@ -11,27 +11,35 @@ export type InjectCIOPodfileOptions = {
   hasPush?: boolean;
 };
 
-/** Builds the host app pod line for the Podfile (single subspec or :subspecs with location). Exported for tests. */
+/** Builds the host-app pod snippet for the Podfile.
+ *
+ * The :path is resolved at prebuild time by `getRelativePathToRNSDK`,
+ * which dispatches on the installed React Native version so the path
+ * matches what RN pod autolinking will emit (lexical for RN <0.80,
+ * realpath for RN >=0.80). Baking the resolved string directly avoids
+ * any Ruby/install-time logic in the Podfile and keeps the snippet
+ * trivially diff-able.
+ *
+ * Exported for tests.
+ */
 export function buildHostAppPodSnippet(
   iosPath: string,
   isFcmPushProvider: boolean,
   options?: InjectCIOPodfileOptions
 ): string {
-  const path = getRelativePathToRNSDK(iosPath);
+  const resolvedPath = getRelativePathToRNSDK(iosPath);
   const locationEnabled = options?.locationEnabled === true;
   const hasPush = options?.hasPush !== false;
 
   if (!locationEnabled) {
     const subspec = isFcmPushProvider ? 'fcm' : 'apn';
-    return `pod 'customerio-reactnative/${subspec}', :path => '${path}'`;
+    return `pod 'customerio-reactnative/${subspec}', :path => '${resolvedPath}'`;
   }
-
   if (!hasPush) {
-    return `pod 'customerio-reactnative', :subspecs => ['location'], :path => '${path}'`;
+    return `pod 'customerio-reactnative', :subspecs => ['location'], :path => '${resolvedPath}'`;
   }
-
   const pushSubspec = isFcmPushProvider ? 'fcm' : 'apn';
-  return `pod 'customerio-reactnative', :subspecs => ['${pushSubspec}', 'location'], :path => '${path}'`;
+  return `pod 'customerio-reactnative', :subspecs => ['${pushSubspec}', 'location'], :path => '${resolvedPath}'`;
 }
 
 export async function injectCIOPodfileCode(
@@ -87,12 +95,16 @@ export async function injectCIONotificationPodfileCode(
   const matches = podfile.match(new RegExp(blockStart));
 
   if (!matches) {
+    const resolvedPath = getRelativePathToRNSDK(iosPath);
+    const subspec = isFcmPushProvider ? 'fcm' : 'apn';
+    const useFrameworksLine =
+      useFrameworks === 'static' ? 'use_frameworks! :linkage => :static' : '';
+
     const snippetToInjectInPodfile = `
 ${blockStart}
 target 'NotificationService' do
-  ${useFrameworks === 'static' ? 'use_frameworks! :linkage => :static' : ''}
-  pod 'customerio-reactnative-richpush/${isFcmPushProvider ? 'fcm' : 'apn'
-      }', :path => '${getRelativePathToRNSDK(iosPath)}'
+  ${useFrameworksLine}
+  pod 'customerio-reactnative-richpush/${subspec}', :path => '${resolvedPath}'
 end
 ${blockEnd}
 `.trim();

package/plugin/src/index.ts

@@ -8,6 +8,7 @@ import type {
   LocationTrackingMode,
   NativeSDKConfig,
 } from './types/cio-types';
+import { withExpoVersion } from './utils/writeExpoVersion';
 
 export type { LocationTrackingMode, NativeSDKConfig };
 
@@ -25,6 +26,12 @@ function withCustomerIOPlugin(
     );
   }
 
+  // Belt-and-suspenders write of the plugin version into the RN SDK's
+  // package.json. The postinstall hook does the same write at install time;
+  // this covers installs where postinstall didn't run cleanly (pnpm with
+  // strict store layouts, --ignore-scripts, cached CI installs, etc).
+  config = withExpoVersion(config);
+
   // Apply platform specific modifications
   config = withCIOIos(config, props.config, props.ios, props.location);
   config = withCIOAndroid(config, props.config, props.android, props.location);

package/plugin/src/ios/withCIOIosSwift.ts

@@ -500,34 +500,47 @@ const addDidFailToRegisterForRemoteNotificationsWithError = (
 
 /**
  * Add deep link handling for killed state
- * This replaces the return statement with deep link handling code
- * and a modified return statement that uses modifiedLaunchOptions
+ *
+ * On modern Expo Swift templates, RN is bootstrapped by `factory.startReactNative(...)`
+ * inside an `#if os(iOS) || os(tvOS)` guard, *before* the trailing `return super.application(...)`.
+ * The deep-link block must run before that call so `modifiedLaunchOptions` flows into RN's
+ * initial launchOptions; otherwise the workaround is a no-op.
+ *
+ * For older templates (no `factory.startReactNative` — `super.application(...)` is what
+ * starts RN), the snippet is injected before the return statement as before.
  */
 const addHandleDeeplinkInKilledState = (content: string): string => {
-  // Check if deep link code snippet is already present
   const deepLinkMarker = 'Deep link workaround for app killed state start';
   if (content.includes(deepLinkMarker)) {
     return content;
   }
 
-  // Find the return statement with launchOptions
   const returnStatementRegex =
     /return\s+super\.application\s*\(\s*application\s*,\s*didFinishLaunchingWithOptions\s*:\s*launchOptions\s*\)/;
-  const returnStatementMatch = content.match(returnStatementRegex);
+  const modifiedReturnStatement =
+    'return super.application(application, didFinishLaunchingWithOptions: modifiedLaunchOptions)';
 
-  if (!returnStatementMatch) {
+  const factoryStartRegex =
+    /(\s*)#if\s+os\(iOS\)\s*\|\|\s*os\(tvOS\)([\s\S]*?factory\.startReactNative\s*\([\s\S]*?launchOptions:\s*)launchOptions(\s*\)[\s\S]*?#endif)/;
+
+  if (factoryStartRegex.test(content)) {
+    let result = content.replace(
+      factoryStartRegex,
+      `\n${CIO_CONFIGUREDEEPLINK_KILLEDSTATE_SWIFT_SNIPPET}\n#if os(iOS) || os(tvOS)$2modifiedLaunchOptions$3`
+    );
+    if (returnStatementRegex.test(result)) {
+      result = result.replace(returnStatementRegex, modifiedReturnStatement);
+    }
+    return result;
+  }
+
+  if (!returnStatementRegex.test(content)) {
     logger.warn('Could not find return statement with launchOptions');
     return content;
   }
-
-  // Create the replacement code with deep link handling and modified return statement
-  const modifiedReturnStatement =
-    'return super.application(application, didFinishLaunchingWithOptions: modifiedLaunchOptions)';
   const replacementCode =
     CIO_CONFIGUREDEEPLINK_KILLEDSTATE_SWIFT_SNIPPET +
     '\n\n    ' +
     modifiedReturnStatement;
-
-  // Replace the return statement with deep link handling code and modified return statement
   return content.replace(returnStatementRegex, replacementCode);
 };

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;
+};