expo-iap 2.9.7 → 3.0.1

package/plugin/src/withIAP.ts

@@ -32,49 +32,74 @@ const addLineToGradle = (
   const lines = content.split('\n');
   const index = lines.findIndex((line) => line.match(anchor));
   if (index === -1) {
-    console.warn(
-      `Anchor "${anchor}" not found in build.gradle. Appending to end.`,
+    WarningAggregator.addWarningAndroid(
+      'expo-iap',
+      `dependencies { ... } block not found; skipping injection: ${lineToAdd.trim()}`,
     );
-    lines.push(lineToAdd);
+    return content;
   } else {
     lines.splice(index + offset, 0, lineToAdd);
   }
   return lines.join('\n');
 };
 
-const modifyAppBuildGradle = (gradle: string): string => {
+const modifyAppBuildGradle = (
+  gradle: string,
+  language: 'groovy' | 'kotlin',
+): string => {
   let modified = gradle;
 
-  // Add billing library dependencies to app-level build.gradle
-  const billingDep = `    implementation "com.android.billingclient:billing-ktx:8.0.0"`;
-  const gmsDep = `    implementation "com.google.android.gms:play-services-base:18.1.0"`;
-
-  let hasAddedDependency = false;
-
-  if (!modified.includes(billingDep)) {
-    modified = addLineToGradle(modified, /dependencies\s*{/, billingDep);
-    hasAddedDependency = true;
-  }
-  if (!modified.includes(gmsDep)) {
-    modified = addLineToGradle(modified, /dependencies\s*{/, gmsDep, 1);
-    hasAddedDependency = true;
+  // Ensure OpenIAP dependency exists at desired version in app-level build.gradle(.kts)
+  const impl = (ga: string, v: string) =>
+    language === 'kotlin'
+      ? `    implementation("${ga}:${v}")`
+      : `    implementation "${ga}:${v}"`;
+  // Pin OpenIAP Google library to 1.1.0
+  const openiapDep = impl('io.github.hyochan.openiap:openiap-google', '1.1.0');
+
+  // Remove any existing openiap-google lines (any version, groovy/kotlin, implementation/api)
+  const openiapAnyLine =
+    /^\s*(?:implementation|api)\s*\(?\s*["']io\.github\.hyochan\.openiap:openiap-google:[^"']+["']\s*\)?\s*$/gm;
+  const hadExisting = openiapAnyLine.test(modified);
+  if (hadExisting) {
+    modified = modified.replace(openiapAnyLine, '').replace(/\n{3,}/g, '\n\n');
   }
 
-  // Log only once and only if we actually added dependencies
-  if (hasAddedDependency)
-    logOnce('🛠️ expo-iap: Added billing dependencies to build.gradle');
+  // Ensure the desired dependency line is present
+  if (
+    !new RegExp(
+      String.raw`io\.github\.hyochan\.openiap:openiap-google:1\.1\.0`,
+    ).test(modified)
+  ) {
+    // Insert just after the opening `dependencies {` line
+    modified = addLineToGradle(modified, /dependencies\s*{/, openiapDep, 1);
+    logOnce(
+      hadExisting
+        ? '🛠️ expo-iap: Replaced OpenIAP dependency with 1.1.0'
+        : '🛠️ expo-iap: Added OpenIAP dependency (1.1.0) to build.gradle',
+    );
+  }
 
   return modified;
 };
 
-const withIapAndroid: ConfigPlugin = (config) => {
-  // Add IAP dependencies to app build.gradle
-  config = withAppBuildGradle(config, (config) => {
-    config.modResults.contents = modifyAppBuildGradle(
-      config.modResults.contents,
-    );
-    return config;
-  });
+const withIapAndroid: ConfigPlugin<{addDeps?: boolean} | void> = (
+  config,
+  props,
+) => {
+  const addDeps = props?.addDeps ?? true;
+
+  if (addDeps) {
+    config = withAppBuildGradle(config, (config) => {
+      // language provided by config-plugins: 'groovy' | 'kotlin'
+      const language = (config.modResults as any).language || 'groovy';
+      config.modResults.contents = modifyAppBuildGradle(
+        config.modResults.contents,
+        language,
+      );
+      return config;
+    });
+  }
 
   config = withAndroidManifest(config, (config) => {
     const manifest = config.modResults;
@@ -140,7 +165,12 @@ const withIapIOS: ConfigPlugin = (config) => {
 
 export interface ExpoIapPluginOptions {
   /** Local development path for OpenIAP library */
-  localPath?: string;
+  localPath?:
+    | string
+    | {
+        ios?: string;
+        android?: string;
+      };
   /** Enable local development mode */
   enableLocalDev?: boolean;
 }
@@ -150,22 +180,36 @@ const withIap: ConfigPlugin<ExpoIapPluginOptions | void> = (
   options,
 ) => {
   try {
-    // Apply Android modifications
-    let result = withIapAndroid(config);
+    // Respect explicit flag; fall back to presence of localPath only when flag is unset
+    const isLocalDev = options?.enableLocalDev ?? !!options?.localPath;
+    // Apply Android modifications (skip adding deps when linking local module)
+    let result = withIapAndroid(config, {addDeps: !isLocalDev});
 
     // iOS: choose one path to avoid overlap
-    if (options?.enableLocalDev || options?.localPath) {
+    if (isLocalDev) {
       if (!options?.localPath) {
         WarningAggregator.addWarningIOS(
           'expo-iap',
           'enableLocalDev is true but no localPath provided. Skipping local OpenIAP integration.',
         );
       } else {
-        const localPath = path.resolve(options.localPath);
-        logOnce(
-          `🔧 [expo-iap] Enabling local OpenIAP development at: ${localPath}`,
-        );
-        result = withLocalOpenIAP(result, {localPath});
+        const raw = options.localPath;
+        const resolved =
+          typeof raw === 'string'
+            ? path.resolve(raw)
+            : {
+                ios: raw.ios ? path.resolve(raw.ios) : undefined,
+                android: raw.android ? path.resolve(raw.android) : undefined,
+              };
+
+        const preview =
+          typeof resolved === 'string'
+            ? resolved
+            : `ios=${resolved.ios ?? 'auto'}, android=${
+                resolved.android ?? 'auto'
+              }`;
+        logOnce(`🔧 [expo-iap] Enabling local OpenIAP: ${preview}`);
+        result = withLocalOpenIAP(result, {localPath: resolved});
       }
     } else {
       // Ensure iOS Podfile is set up to resolve public CocoaPods specs

package/plugin/src/withLocalOpenIAP.ts

@@ -1,4 +1,9 @@
-import {ConfigPlugin, withDangerousMod} from '@expo/config-plugins';
+import {
+  ConfigPlugin,
+  withDangerousMod,
+  withSettingsGradle,
+  withAppBuildGradle,
+} from 'expo/config-plugins';
 import * as fs from 'fs';
 import * as path from 'path';
 
@@ -6,46 +11,60 @@ import * as path from 'path';
  * Plugin to add local OpenIAP pod dependency for development
  * This is only for local development with openiap-apple library
  */
-const withLocalOpenIAP: ConfigPlugin<{localPath?: string} | void> = (
+type LocalPathOption = string | {ios?: string; android?: string};
+
+const withLocalOpenIAP: ConfigPlugin<{localPath?: LocalPathOption} | void> = (
   config,
   props,
 ) => {
-  return withDangerousMod(config, [
+  // Helper to resolve Android module path
+  const resolveAndroidModulePath = (p?: string): string | null => {
+    if (!p) return null;
+    // Prefer the module directory if it exists
+    const candidates = [
+      path.join(p, 'openiap-google'),
+      path.join(p, 'openiap'),
+      p,
+    ];
+    for (const c of candidates) {
+      if (
+        fs.existsSync(path.join(c, 'build.gradle')) ||
+        fs.existsSync(path.join(c, 'build.gradle.kts'))
+      ) {
+        return c;
+      }
+    }
+    return null;
+  };
+
+  // iOS: inject local pod path
+  config = withDangerousMod(config, [
     'ios',
     async (config) => {
-      const {platformProjectRoot} = config.modRequest;
+      const {platformProjectRoot, projectRoot} = config.modRequest as any;
+      const raw = props?.localPath;
+      const iosPath =
+        (typeof raw === 'string' ? raw : raw?.ios) ||
+        path.resolve(projectRoot, 'openiap-apple');
       const podfilePath = path.join(platformProjectRoot, 'Podfile');
 
-      // Default local path or use provided one
-      const localOpenIapPath =
-        props?.localPath ||
-        path.resolve(config.modRequest.projectRoot, 'openiap-apple');
-
-      // Check if local path exists
-      if (!fs.existsSync(localOpenIapPath)) {
-        console.warn(
-          `⚠️  Local openiap-apple path not found: ${localOpenIapPath}`,
-        );
-        console.warn(
-          '   Skipping local pod injection. Using default pod resolution.',
-        );
+      if (!fs.existsSync(iosPath)) {
+        console.warn(`⚠️  Local openiap-apple path not found: ${iosPath}`);
+        console.warn('   Skipping local pod injection.');
         return config;
       }
 
-      // Read Podfile
       if (!fs.existsSync(podfilePath)) {
         console.warn(`⚠️  Podfile not found at ${podfilePath}. Skipping.`);
         return config;
       }
       let podfileContent = fs.readFileSync(podfilePath, 'utf8');
 
-      // Check if already has the local pod reference
       if (podfileContent.includes("pod 'openiap',")) {
         console.log('✅ Local OpenIAP pod already configured');
         return config;
       }
 
-      // Find the target block and inject the local pod
       const targetRegex =
         /target\s+['"][\w]+['"]\s+do\s*\n\s*use_expo_modules!/;
 
@@ -54,12 +73,10 @@ const withLocalOpenIAP: ConfigPlugin<{localPath?: string} | void> = (
           return `${match}
   
   # Local OpenIAP pod for development (added by expo-iap plugin)
-  pod 'openiap', :path => '${localOpenIapPath}'`;
+  pod 'openiap', :path => '${iosPath}'`;
         });
-
-        // Write back to Podfile
         fs.writeFileSync(podfilePath, podfileContent);
-        console.log(`✅ Added local OpenIAP pod at: ${localOpenIapPath}`);
+        console.log(`✅ Added local OpenIAP pod at: ${iosPath}`);
       } else {
         console.warn('⚠️  Could not find target block in Podfile');
       }
@@ -67,6 +84,197 @@ const withLocalOpenIAP: ConfigPlugin<{localPath?: string} | void> = (
       return config;
     },
   ]);
+
+  // Android: include local module and add dependency if available
+  config = withSettingsGradle(config, (config) => {
+    const raw = props?.localPath;
+    const projectRoot = (config.modRequest as any).projectRoot as string;
+    const androidInput = typeof raw === 'string' ? undefined : raw?.android;
+    const androidModulePath =
+      resolveAndroidModulePath(androidInput) ||
+      resolveAndroidModulePath(path.resolve(projectRoot, 'openiap-google')) ||
+      null;
+
+    if (!androidModulePath || !fs.existsSync(androidModulePath)) {
+      if (androidInput) {
+        console.warn(
+          `⚠️  Could not resolve Android OpenIAP module at: ${androidInput}. Skipping local Android linkage.`,
+        );
+      }
+      return config;
+    }
+
+    // 1) settings.gradle: include and map projectDir
+    const settings = config.modResults;
+    const includeLine = "include ':openiap-google'";
+    const projectDirLine = `project(':openiap-google').projectDir = new File('${androidModulePath.replace(
+      /\\/g,
+      '/',
+    )}')`;
+    let contents = settings.contents ?? '';
+
+    // Ensure pluginManagement has plugin mappings required by the included module
+    const injectPluginManagement = () => {
+      const header = 'pluginManagement {';
+      const needsVannik =
+        !/id\s*\(\s*["']com\.vanniktech\.maven\.publish["']/.test(contents);
+      const needsKotlinAndroid =
+        !/id\s*\(\s*["']org\.jetbrains\.kotlin\.android["']/.test(contents);
+      const needsCompose =
+        !/id\s*\(\s*["']org\.jetbrains\.kotlin\.plugin\.compose["']/.test(
+          contents,
+        );
+      const needsRepos = !/pluginManagement[\s\S]*?repositories\s*\{/.test(
+        contents,
+      );
+
+      const pluginLines: string[] = [];
+      if (needsVannik)
+        pluginLines.push(
+          `  id("com.vanniktech.maven.publish") version "0.29.0"`,
+        );
+      if (needsKotlinAndroid)
+        pluginLines.push(
+          `  id("org.jetbrains.kotlin.android") version "2.0.21"`,
+        );
+      if (needsCompose)
+        pluginLines.push(
+          `  id("org.jetbrains.kotlin.plugin.compose") version "2.0.21"`,
+        );
+
+      // If everything already present, skip
+      if (pluginLines.length === 0 && !needsRepos) return;
+
+      const pluginsBlock = pluginLines.length
+        ? `plugins {\n${pluginLines.join('\n')}\n}`
+        : '';
+      const reposBlock = `repositories { gradlePluginPortal(); google(); mavenCentral() }`;
+
+      if (contents.includes(header)) {
+        contents = contents.replace(/pluginManagement\s*\{/, (m) => {
+          let injection =
+            m + `\n  // Added by expo-iap (local openiap-google)\n`;
+          if (pluginsBlock) injection += `  ${pluginsBlock}\n`;
+          if (needsRepos) injection += `  ${reposBlock}\n`;
+          return injection;
+        });
+      } else {
+        contents =
+          `pluginManagement {\n  // Added by expo-iap (local openiap-google)\n` +
+          (pluginsBlock ? `  ${pluginsBlock}\n` : '') +
+          `  ${reposBlock}\n}\n\n${contents}`;
+      }
+    };
+
+    if (
+      !/com\.vanniktech\.maven\.publish/.test(contents) ||
+      !/org\.jetbrains\.kotlin\.android/.test(contents)
+    ) {
+      injectPluginManagement();
+    }
+    if (!contents.includes(includeLine)) contents += `\n${includeLine}\n`;
+    if (!contents.includes(projectDirLine)) contents += `${projectDirLine}\n`;
+    settings.contents = contents;
+    console.log(`✅ Linked local Android module at: ${androidModulePath}`);
+    return config;
+  });
+
+  // 2) app/build.gradle: add implementation project(':openiap-google')
+  config = withAppBuildGradle(config, (config) => {
+    const raw = props?.localPath;
+    const projectRoot = (config.modRequest as any).projectRoot as string;
+    const androidInput = typeof raw === 'string' ? undefined : raw?.android;
+    const androidModulePath =
+      resolveAndroidModulePath(androidInput) ||
+      resolveAndroidModulePath(path.resolve(projectRoot, 'openiap-google')) ||
+      null;
+
+    if (!androidModulePath || !fs.existsSync(androidModulePath)) {
+      return config;
+    }
+
+    const gradle = config.modResults;
+    const dependencyLine = `    implementation project(':openiap-google')`;
+
+    // Remove any previously added Maven deps for openiap-google to avoid duplicate classes
+    const removalPatterns = [
+      // Groovy DSL: implementation "io.github.hyochan.openiap:openiap-google:x.y.z" or api "..."
+      /^\s*(?:implementation|api)\s+["']io\.github\.hyochan\.openiap:openiap-google:[^"']+["']\s*$/gm,
+      // Kotlin DSL: implementation("io.github.hyochan.openiap:openiap-google:x.y.z") or api("...")
+      /^\s*(?:implementation|api)\s*\(\s*["']io\.github\.hyochan\.openiap:openiap-google:[^"']+["']\s*\)\s*$/gm,
+    ];
+    let contents = gradle.contents;
+    let removedAny = false;
+    for (const pattern of removalPatterns) {
+      if (pattern.test(contents)) {
+        contents = contents.replace(pattern, '\n');
+        removedAny = true;
+      }
+    }
+    if (removedAny) {
+      gradle.contents = contents;
+      console.log(
+        '🧹 Removed Maven openiap-google to use local :openiap-google',
+      );
+    }
+    if (!gradle.contents.includes(dependencyLine)) {
+      const anchor = /dependencies\s*\{/m;
+      if (anchor.test(gradle.contents)) {
+        gradle.contents = gradle.contents.replace(
+          anchor,
+          (m) => `${m}\n${dependencyLine}`,
+        );
+      } else {
+        gradle.contents += `\n\ndependencies {\n${dependencyLine}\n}\n`;
+      }
+      console.log('🛠️ Added dependency on local :openiap-google project');
+    }
+    return config;
+  });
+
+  // 3) Ensure final cleanup in app/build.gradle after all mods are applied
+  config = withDangerousMod(config, [
+    'android',
+    async (config) => {
+      try {
+        const {platformProjectRoot} = config.modRequest as any;
+        const appBuildGradle = path.join(
+          platformProjectRoot,
+          'app',
+          'build.gradle',
+        );
+        if (fs.existsSync(appBuildGradle)) {
+          let contents = fs.readFileSync(appBuildGradle, 'utf8');
+          const patterns = [
+            // Groovy DSL
+            /^\s*(?:implementation|api)\s+["']io\.github\.hyochan\.openiap:openiap-google:[^"']+["']\s*$/gm,
+            // Kotlin DSL
+            /^\s*(?:implementation|api)\s*\(\s*["']io\.github\.hyochan\.openiap:openiap-google:[^"']+["']\s*\)\s*$/gm,
+          ];
+          let changed = false;
+          for (const p of patterns) {
+            if (p.test(contents)) {
+              contents = contents.replace(p, '\n');
+              changed = true;
+            }
+          }
+          if (changed) {
+            fs.writeFileSync(appBuildGradle, contents);
+            console.log(
+              '🧹 expo-iap: Cleaned Maven openiap-google for local :openiap-google',
+            );
+          }
+        }
+      } catch (e) {
+        console.warn('expo-iap: cleanup step failed:', e);
+      }
+      return config;
+    },
+  ]);
+
+  // (removed) Avoid global root build.gradle mutations; included module should manage its plugins
+
+  return config;
 };
 
 export default withLocalOpenIAP;

package/src/ExpoIap.types.ts

@@ -37,7 +37,6 @@ export type PurchaseCommon = {
   id: string; // Transaction identifier - used by finishTransaction
   productId: string; // Product identifier - which product was purchased
   ids?: string[]; // Product identifiers for purchases that include multiple products
-  transactionId?: string; // @deprecated - use id instead
   transactionDate: number;
   transactionReceipt: string;
   purchaseToken?: string; // Unified purchase token (jwsRepresentation for iOS, purchaseToken for Android)
@@ -70,17 +69,11 @@ export type Purchase =
   | (PurchaseAndroid & AndroidPlatform)
   | (PurchaseIOS & IosPlatform);
 
-// Removed legacy type aliases `ProductPurchase` and `SubscriptionPurchase` in v2.9.0
-
 export type PurchaseResult = {
   responseCode?: number;
   debugMessage?: string;
   code?: string;
   message?: string;
-  /**
-   * @deprecated Use `purchaseToken` instead. This field will be removed in a future version.
-   */
-  purchaseTokenAndroid?: string;
   purchaseToken?: string;
 };
 /**
@@ -399,7 +392,6 @@ export interface RequestPurchaseAndroidProps {
  */
 export interface RequestSubscriptionAndroidProps
   extends RequestPurchaseAndroidProps {
-  readonly purchaseTokenAndroid?: string;
   readonly replacementModeAndroid?: number;
   readonly subscriptionOffers: {
     sku: string;

package/src/helpers/subscription.ts

@@ -39,7 +39,8 @@ export const getActiveSubscriptions = async (
       // Check if this purchase has subscription-specific fields
       const hasSubscriptionFields =
         ('expirationDateIOS' in purchase && !!purchase.expirationDateIOS) ||
-        'autoRenewingAndroid' in purchase;
+        'autoRenewingAndroid' in purchase ||
+        ('environmentIOS' in purchase && !!(purchase as any).environmentIOS);
 
       if (!hasSubscriptionFields) {
         return false;
@@ -76,12 +77,22 @@ export const getActiveSubscriptions = async (
       return false;
     });
 
+    // Deduplicate by transaction identifier (id)
+    const seen = new Set<string>();
+    const dedupedPurchases = filteredPurchases.filter((p) => {
+      const key = String(p.id);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+
     // Convert to ActiveSubscription format
-    for (const purchase of filteredPurchases) {
+    for (const purchase of dedupedPurchases) {
       const subscription: ActiveSubscription = {
         productId: purchase.productId,
         isActive: true,
-        transactionId: purchase.transactionId || purchase.id,
+        // Use unified id as transaction identifier in v3
+        transactionId: purchase.id,
         purchaseToken: purchase.purchaseToken,
         transactionDate: purchase.transactionDate,
       };