fix: add missing AppTransaction properties and fix native method name (#107)

## Summary

This PR fixes the iOS build errors reported in #106 by adding missing
AppTransaction properties and correcting the native method name.
https://developer.apple.com/documentation/storekit/apptransaction

## Changes

- **Add all missing AppTransaction properties** to match Apple's API
documentation:
- `appTransactionID` - The unique identifier (this was the main missing
property)
  - `environment` - App Store environment 
  - `signedDate` - When the transaction was signed
  - `appID` - App Store app ID
  - `appVersionID` - App Store version ID
  - `originalPlatform` - Platform of original purchase
  - `preorderDate` - Pre-order date if applicable

- **Fix native method name**: `validateReceiptIos` →
`validateReceiptIOS` to match TypeScript calls

- **Update TypeScript types**: Added all properties to
`AppTransactionIOS` type definition

## Fixes
Fixes #106 - iOS build error with missing AppTransaction properties

## Testing
- [ ] Build passes on iOS
- [ ] AppTransaction returns all properties correctly
- [ ] validateReceiptIOS works as expected

Author: hyochan

docs/blog/2025-07-22-v2-6-2-release.md

@@ -0,0 +1,109 @@
+---
+slug: v2-6-2-release
+title: Version 2.6.2 - iOS AppTransaction Support
+authors: [hyochan]
+tags: [release, ios, apptransaction]
+---
+
+# Version 2.6.2 Release: Enhanced iOS AppTransaction Support
+
+We're excited to announce the release of expo-iap version 2.6.2, which includes critical fixes for iOS AppTransaction functionality.
+
+## What's New
+
+### Complete AppTransaction Properties
+
+The `getAppTransactionIOS()` function now returns all properties available from Apple's StoreKit 2 AppTransaction API:
+
+```typescript
+export type AppTransactionIOS = {
+  appTransactionID: string;
+  bundleID: string;
+  appVersion: string;
+  originalAppVersion: string;
+  originalPurchaseDate: number;
+  deviceVerification: string;
+  deviceVerificationNonce: string;
+  environment: string;
+  signedDate: number;
+  appID?: number;
+  appVersionID?: number;
+  originalPlatform: string;
+  preorderDate?: number;
+};
+```
+
+### Key Properties Added
+
+- **`appTransactionID`**: The unique identifier for the app transaction
+- **`environment`**: Indicates whether the transaction occurred in Production, Sandbox, or Xcode environment
+- **`signedDate`**: The date when the transaction was signed
+- **`appID`** and **`appVersionID`**: App Store identifiers for the app and version
+- **`originalPlatform`**: The platform where the app was originally purchased
+- **`preorderDate`**: Available when the app was pre-ordered
+
+## Usage Example
+
+```typescript
+import { getAppTransactionIOS } from 'expo-iap';
+
+const getAppPurchaseInfo = async () => {
+  try {
+    const appTransaction = await getAppTransactionIOS();
+    
+    console.log('App Transaction ID:', appTransaction.appTransactionID);
+    console.log('Environment:', appTransaction.environment);
+    console.log('Original Purchase Date:', new Date(appTransaction.originalPurchaseDate));
+    
+    // Check if app was pre-ordered
+    if (appTransaction.preorderDate) {
+      console.log('Pre-order Date:', new Date(appTransaction.preorderDate));
+    }
+  } catch (error) {
+    console.error('Failed to get app transaction:', error);
+  }
+};
+```
+
+## Why This Matters
+
+The AppTransaction API provides crucial information about the app's purchase and installation:
+
+- **Verify app authenticity**: Use the device verification data to ensure the app is legitimate
+- **Track installation source**: Determine if the app was purchased, redeemed, or installed via TestFlight
+- **Environment detection**: Easily identify if you're running in production or sandbox
+- **Pre-order support**: Handle pre-ordered apps appropriately
+
+## Requirements
+
+- iOS 16.0 or later
+- The function will throw an error on older iOS versions
+
+## Bug Fixes
+
+This release also includes:
+- Fixed missing properties in AppTransaction type definition
+- Corrected property names to match Apple's API exactly
+- Fixed TypeScript type exports
+
+## Upgrading
+
+To upgrade to version 2.6.2:
+
+```bash
+npm install expo-iap@2.6.2
+# or
+yarn add expo-iap@2.6.2
+# or
+bun add expo-iap@2.6.2
+```
+
+## What's Next
+
+We're continuing to improve the iOS integration and will be adding more StoreKit 2 features in upcoming releases. Stay tuned!
+
+## Feedback
+
+If you encounter any issues or have suggestions, please [open an issue](https://github.com/hyochan/expo-iap/issues) on our GitHub repository.
+
+Happy coding! 🚀

example/__tests__/app-transaction.test.tsx

@@ -0,0 +1,79 @@
+describe('AppTransaction Type Tests', () => {
+  it('should validate AppTransactionIOS type structure', () => {
+    // This test validates that we have the correct type structure
+    // It doesn't run actual code but ensures TypeScript compilation
+    const mockTransaction = {
+      appTransactionID: 'test-id',
+      bundleID: 'com.example.app',
+      appVersion: '1.0.0',
+      originalAppVersion: '1.0.0',
+      originalPurchaseDate: Date.now(),
+      deviceVerification: 'verification-data',
+      deviceVerificationNonce: 'nonce',
+      environment: 'Production',
+      signedDate: Date.now(),
+      appID: 123456,
+      appVersionID: 789012,
+      originalPlatform: 'iOS',
+      preorderDate: undefined,
+    };
+
+    // Test that all properties exist
+    expect(mockTransaction).toHaveProperty('appTransactionID');
+    expect(mockTransaction).toHaveProperty('bundleID');
+    expect(mockTransaction).toHaveProperty('appVersion');
+    expect(mockTransaction).toHaveProperty('originalAppVersion');
+    expect(mockTransaction).toHaveProperty('originalPurchaseDate');
+    expect(mockTransaction).toHaveProperty('deviceVerification');
+    expect(mockTransaction).toHaveProperty('deviceVerificationNonce');
+    expect(mockTransaction).toHaveProperty('environment');
+    expect(mockTransaction).toHaveProperty('signedDate');
+    expect(mockTransaction).toHaveProperty('appID');
+    expect(mockTransaction).toHaveProperty('appVersionID');
+    expect(mockTransaction).toHaveProperty('originalPlatform');
+  });
+
+  it('should handle optional preorderDate', () => {
+    const transactionWithPreorder = {
+      appTransactionID: 'test-id',
+      bundleID: 'com.example.app',
+      appVersion: '1.0.0',
+      originalAppVersion: '1.0.0',
+      originalPurchaseDate: Date.now(),
+      deviceVerification: 'verification-data',
+      deviceVerificationNonce: 'nonce',
+      environment: 'Production',
+      signedDate: Date.now(),
+      appID: 123456,
+      appVersionID: 789012,
+      originalPlatform: 'iOS',
+      preorderDate: Date.now(),
+    };
+
+    expect(transactionWithPreorder.preorderDate).toBeDefined();
+    expect(typeof transactionWithPreorder.preorderDate).toBe('number');
+  });
+
+  it('should have correct property types', () => {
+    const mockTransaction = {
+      appTransactionID: 'test-id',
+      bundleID: 'com.example.app',
+      appVersion: '1.0.0',
+      originalAppVersion: '1.0.0',
+      originalPurchaseDate: Date.now(),
+      deviceVerification: 'verification-data',
+      deviceVerificationNonce: 'nonce',
+      environment: 'Production',
+      signedDate: Date.now(),
+      appID: 123456,
+      appVersionID: 789012,
+      originalPlatform: 'iOS',
+    };
+
+    expect(typeof mockTransaction.appTransactionID).toBe('string');
+    expect(typeof mockTransaction.bundleID).toBe('string');
+    expect(typeof mockTransaction.appVersion).toBe('string');
+    expect(typeof mockTransaction.originalPurchaseDate).toBe('number');
+    expect(typeof mockTransaction.appID).toBe('number');
+  });
+});

example/__tests__/core-functions.test.tsx

@@ -0,0 +1,121 @@
+import * as ExpoIap from 'expo-iap';
+
+describe('Core Functions Tests', () => {
+  describe('Core Module Exports', () => {
+    it('should export initConnection function', () => {
+      expect(ExpoIap.initConnection).toBeDefined();
+      expect(typeof ExpoIap.initConnection).toBe('function');
+    });
+
+    it('should export endConnection function', () => {
+      expect(ExpoIap.endConnection).toBeDefined();
+      expect(typeof ExpoIap.endConnection).toBe('function');
+    });
+
+    it('should export getProducts function', () => {
+      expect(ExpoIap.getProducts).toBeDefined();
+      expect(typeof ExpoIap.getProducts).toBe('function');
+    });
+
+    it('should export getSubscriptions function', () => {
+      expect(ExpoIap.getSubscriptions).toBeDefined();
+      expect(typeof ExpoIap.getSubscriptions).toBe('function');
+    });
+
+    it('should export requestPurchase function', () => {
+      expect(ExpoIap.requestPurchase).toBeDefined();
+      expect(typeof ExpoIap.requestPurchase).toBe('function');
+    });
+
+    it('should export finishTransaction function', () => {
+      expect(ExpoIap.finishTransaction).toBeDefined();
+      expect(typeof ExpoIap.finishTransaction).toBe('function');
+    });
+
+    it('should export getPurchaseHistories function', () => {
+      expect(ExpoIap.getPurchaseHistories).toBeDefined();
+      expect(typeof ExpoIap.getPurchaseHistories).toBe('function');
+    });
+
+    it('should export getAvailablePurchases function', () => {
+      expect(ExpoIap.getAvailablePurchases).toBeDefined();
+      expect(typeof ExpoIap.getAvailablePurchases).toBe('function');
+    });
+
+    it('should export getStorefrontIOS function', () => {
+      expect(ExpoIap.getStorefrontIOS).toBeDefined();
+      expect(typeof ExpoIap.getStorefrontIOS).toBe('function');
+    });
+
+    it('should export deprecated getStorefront function', () => {
+      expect(ExpoIap.getStorefront).toBeDefined();
+      expect(typeof ExpoIap.getStorefront).toBe('function');
+    });
+  });
+
+  describe('Event Listeners', () => {
+    it('should export purchaseUpdatedListener', () => {
+      expect(ExpoIap.purchaseUpdatedListener).toBeDefined();
+      expect(typeof ExpoIap.purchaseUpdatedListener).toBe('function');
+    });
+
+    it('should export purchaseErrorListener', () => {
+      expect(ExpoIap.purchaseErrorListener).toBeDefined();
+      expect(typeof ExpoIap.purchaseErrorListener).toBe('function');
+    });
+  });
+
+  describe('Hook', () => {
+    it('should export useIAP hook', () => {
+      expect(ExpoIap.useIAP).toBeDefined();
+      expect(typeof ExpoIap.useIAP).toBe('function');
+    });
+  });
+
+  describe('Android Functions', () => {
+    it('should export deepLinkToSubscriptionsAndroid', () => {
+      expect(ExpoIap.deepLinkToSubscriptionsAndroid).toBeDefined();
+      expect(typeof ExpoIap.deepLinkToSubscriptionsAndroid).toBe('function');
+    });
+
+    it('should export validateReceiptAndroid', () => {
+      expect(ExpoIap.validateReceiptAndroid).toBeDefined();
+      expect(typeof ExpoIap.validateReceiptAndroid).toBe('function');
+    });
+
+    it('should export acknowledgeProductAndroid', () => {
+      expect(ExpoIap.acknowledgeProductAndroid).toBeDefined();
+      expect(typeof ExpoIap.acknowledgeProductAndroid).toBe('function');
+    });
+
+    it('should export consumeProductAndroid', () => {
+      expect(ExpoIap.consumeProductAndroid).toBeDefined();
+      expect(typeof ExpoIap.consumeProductAndroid).toBe('function');
+    });
+  });
+
+  describe('Enums and Constants', () => {
+    it('should export IapEvent enum', () => {
+      expect(ExpoIap.IapEvent).toBeDefined();
+      expect(ExpoIap.IapEvent.PurchaseUpdated).toBe('purchase-updated');
+      expect(ExpoIap.IapEvent.PurchaseError).toBe('purchase-error');
+    });
+
+    it('should export ErrorCode enum', () => {
+      expect(ExpoIap.ErrorCode).toBeDefined();
+      expect(typeof ExpoIap.ErrorCode).toBe('object');
+    });
+  });
+
+  describe('Type Guards', () => {
+    it('should export isProductIos function', () => {
+      expect(ExpoIap.isProductIos).toBeDefined();
+      expect(typeof ExpoIap.isProductIos).toBe('function');
+    });
+
+    it('should export isProductAndroid function', () => {
+      expect(ExpoIap.isProductAndroid).toBeDefined();
+      expect(typeof ExpoIap.isProductAndroid).toBe('function');
+    });
+  });
+});

example/__tests__/index.test.tsx

@@ -0,0 +1,71 @@
+import React from 'react';
+import { render, waitFor } from '@testing-library/react-native';
+import { Platform } from 'react-native';
+import Home from '../app/index';
+
+// Mock expo-router
+jest.mock('expo-router', () => ({
+  Link: ({ children }: any) => children,
+}));
+
+// Mock expo-iap
+jest.mock('expo-iap', () => ({
+  getStorefrontIOS: jest.fn(() => Promise.resolve('US')),
+}));
+
+describe('Home Component', () => {
+  const originalPlatform = Platform.OS;
+  
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  
+  afterEach(() => {
+    Object.defineProperty(Platform, 'OS', {
+      get: jest.fn(() => originalPlatform),
+      configurable: true,
+    });
+  });
+
+  it('should render without crashing', () => {
+    const { getByText } = render(<Home />);
+    expect(getByText('expo-iap Examples')).toBeDefined();
+  });
+
+  it('should render on iOS platform', async () => {
+    // Mock Platform.OS to be iOS
+    Object.defineProperty(Platform, 'OS', {
+      get: jest.fn(() => 'ios'),
+      configurable: true,
+    });
+    
+    const getStorefrontIOS = require('expo-iap').getStorefrontIOS;
+    
+    const { getByText } = render(<Home />);
+    expect(getByText('expo-iap Examples')).toBeDefined();
+    
+    // Wait for async operations to complete
+    await waitFor(() => {
+      expect(getStorefrontIOS).toHaveBeenCalled();
+    });
+  });
+
+  it('should render on Android platform', () => {
+    // Mock Platform.OS to be Android
+    Object.defineProperty(Platform, 'OS', {
+      get: jest.fn(() => 'android'),
+      configurable: true,
+    });
+    
+    const consoleWarn = jest.spyOn(console, 'warn').mockImplementation();
+    
+    const { getByText } = render(<Home />);
+    expect(getByText('expo-iap Examples')).toBeDefined();
+    
+    // No async operations on Android
+    const getStorefrontIOS = require('expo-iap').getStorefrontIOS;
+    expect(getStorefrontIOS).not.toHaveBeenCalled();
+    
+    consoleWarn.mockRestore();
+  });
+});