@namiml/expo-nami-iap 3.4.0-dev.202605060437

package/src/ExpoNamiIapModule.kepler.ts

@@ -0,0 +1,200 @@
+/**
+ * ExpoNamiIapModule — Kepler/Vega implementation.
+ *
+ * Metro resolves this file instead of `index.ts` when `Platform.OS === 'kepler'`.
+ * It wraps `@amazon-devices/keplerscript-appstore-iap-lib` to provide the same
+ * public API surface as the native-backed module.
+ */
+
+import type {
+  ConfigureOptions,
+  EligibilityResult,
+  ExpoNamiIapError,
+  ExpoNamiIapProduct,
+  ExpoNamiIapTransaction,
+  PurchaseOptions,
+} from './types';
+
+export * from './types';
+
+/* ---------- Kepler IAP library (lazy require) ---------- */
+
+function getKeplerIAP() {
+  return require('@amazon-devices/keplerscript-appstore-iap-lib');
+}
+
+/* ---------- In-memory event emitter ---------- */
+
+type TransactionListener = (tx: ExpoNamiIapTransaction) => void;
+type ErrorListener = (err: ExpoNamiIapError) => void;
+
+const transactionListeners = new Set<TransactionListener>();
+const errorListeners = new Set<ErrorListener>();
+
+function emitTransaction(tx: ExpoNamiIapTransaction): void {
+  for (const cb of transactionListeners) {
+    cb(tx);
+  }
+}
+
+/* ---------- Public API ---------- */
+
+/**
+ * No-op on Kepler — no native configuration needed.
+ */
+export function configure(_options: ConfigureOptions): void {
+  // Intentional no-op
+}
+
+/**
+ * No-op on Kepler — the IAP library is promise-based, no listener to register.
+ */
+export async function initConnection(): Promise<void> {
+  // Intentional no-op
+}
+
+/**
+ * No-op on Kepler — nothing to tear down.
+ */
+export async function endConnection(): Promise<void> {
+  // Intentional no-op
+}
+
+/**
+ * Fetch product details from the Kepler IAP service.
+ * Prices are returned in micro-units and divided by 1,000,000.
+ */
+export async function getProducts(skuIds: string[]): Promise<ExpoNamiIapProduct[]> {
+  const IAP = getKeplerIAP();
+  const request = new IAP.ProductDataRequest(skuIds);
+  const response = await IAP.PurchaseManager.getProductData(request);
+
+  return Object.values(response.productData ?? {}).map((product: any) => ({
+    product_ref_id: product.sku,
+    name: product.title,
+    description: product.description,
+    product_type:
+      product.productType === 'SUBSCRIPTION'
+        ? ('subscription' as const)
+        : ('one_time_purchase' as const),
+    offers: [
+      {
+        offer_type: 'default' as const,
+        price: (product.price?.priceValue ?? 0) / 1_000_000,
+        currency: product.price?.currencyCode ?? 'USD',
+      },
+    ],
+  })) as ExpoNamiIapProduct[];
+}
+
+/**
+ * Best-effort eligibility check.
+ * Returns `introEligible: true` when no active receipt exists for the SKU.
+ */
+export async function checkEligibility(skuIds: string[]): Promise<EligibilityResult[]> {
+  const IAP = getKeplerIAP();
+  const request = new IAP.PurchaseUpdatesRequest(true);
+  const response = await IAP.PurchaseManager.getPurchaseUpdates(request);
+
+  const ownedSkus = new Set<string>(
+    (response.receipts ?? []).map((r: any) => r.sku),
+  );
+
+  return skuIds.map((skuId) => ({
+    skuId,
+    introEligible: !ownedSkus.has(skuId),
+    promoEligible: false,
+  }));
+}
+
+/**
+ * Initiate a purchase and notify fulfillment on success.
+ * The resulting transaction is also emitted to registered listeners.
+ */
+export async function purchase(options: PurchaseOptions): Promise<ExpoNamiIapTransaction> {
+  const IAP = getKeplerIAP();
+  const skuId = options.skuId;
+
+  const request = new IAP.PurchaseRequest(skuId);
+  const response = await IAP.PurchaseManager.purchase(request);
+
+  // Notify fulfillment
+  if (response.receiptId) {
+    const fulfillment = new IAP.NotifyFulfillmentRequest(
+      response.receiptId,
+      IAP.FulfillmentResult.SUCCEEDED,
+    );
+    await IAP.PurchaseManager.notifyFulfillment(fulfillment);
+  }
+
+  const tx: ExpoNamiIapTransaction = {
+    skuId: response.sku ?? skuId,
+    transactionId: response.receiptId,
+    originalTransactionId: response.receiptId,
+    receipt: response.receiptId,
+    purchaseToken: response.receiptId,
+    purchaseTime: Date.now(),
+  };
+
+  emitTransaction(tx);
+
+  return tx;
+}
+
+/**
+ * Restore previous purchases from the Kepler IAP service.
+ */
+export async function restorePurchases(): Promise<ExpoNamiIapTransaction[]> {
+  const IAP = getKeplerIAP();
+  const request = new IAP.PurchaseUpdatesRequest(true);
+  const response = await IAP.PurchaseManager.getPurchaseUpdates(request);
+
+  return (response.receipts ?? []).map((receipt: any) => ({
+    skuId: receipt.sku,
+    transactionId: receipt.receiptId,
+    originalTransactionId: receipt.receiptId,
+    receipt: receipt.receiptId,
+    purchaseToken: receipt.receiptId,
+    purchaseTime: receipt.purchaseDate ?? receipt.cancelDate,
+  }));
+}
+
+/**
+ * Finish (acknowledge) a transaction by notifying fulfillment.
+ */
+export async function finishTransaction(transactionId: string): Promise<void> {
+  const IAP = getKeplerIAP();
+  const fulfillment = new IAP.NotifyFulfillmentRequest(
+    transactionId,
+    IAP.FulfillmentResult.SUCCEEDED,
+  );
+  await IAP.PurchaseManager.notifyFulfillment(fulfillment);
+}
+
+/**
+ * Subscribe to transaction updates. Returns a subscription with a `remove()` method.
+ */
+export function addTransactionListener(
+  cb: (tx: ExpoNamiIapTransaction) => void,
+): { remove: () => void } {
+  transactionListeners.add(cb);
+  return {
+    remove: () => {
+      transactionListeners.delete(cb);
+    },
+  };
+}
+
+/**
+ * Subscribe to error events. Returns a subscription with a `remove()` method.
+ */
+export function addErrorListener(
+  cb: (err: ExpoNamiIapError) => void,
+): { remove: () => void } {
+  errorListeners.add(cb);
+  return {
+    remove: () => {
+      errorListeners.delete(cb);
+    },
+  };
+}

package/src/ExpoNamiIapModule.ts

@@ -0,0 +1,18 @@
+import { EventEmitter, requireNativeModule } from 'expo-modules-core';
+
+export interface NativeExpoNamiIapModule {
+  configure(options: unknown): void;
+  initConnection(): Promise<void>;
+  endConnection(): Promise<void>;
+  getProducts(skuIds: string[]): Promise<unknown[]>;
+  checkEligibility(skuIds: string[]): Promise<unknown[]>;
+  purchase(options: unknown): Promise<unknown>;
+  restorePurchases(): Promise<unknown[]>;
+  finishTransaction(transactionId: string): Promise<void>;
+}
+
+const NativeModule = requireNativeModule<NativeExpoNamiIapModule>('ExpoNamiIapModule');
+
+export const emitter = new EventEmitter(NativeModule);
+
+export default NativeModule;

package/src/index.ts

@@ -0,0 +1,63 @@
+import NativeModule, { emitter } from './ExpoNamiIapModule';
+import type {
+  ConfigureOptions,
+  EligibilityResult,
+  ExpoNamiIapError,
+  ExpoNamiIapProduct,
+  ExpoNamiIapTransaction,
+  PurchaseOptions,
+} from './types';
+
+export * from './types';
+
+export function configure(options: ConfigureOptions): void {
+  NativeModule.configure(options);
+}
+
+export function initConnection(): Promise<void> {
+  return NativeModule.initConnection();
+}
+
+export function endConnection(): Promise<void> {
+  return NativeModule.endConnection();
+}
+
+export function getProducts(skuIds: string[]): Promise<ExpoNamiIapProduct[]> {
+  return NativeModule.getProducts(skuIds) as Promise<ExpoNamiIapProduct[]>;
+}
+
+export function checkEligibility(skuIds: string[]): Promise<EligibilityResult[]> {
+  return NativeModule.checkEligibility(skuIds) as Promise<EligibilityResult[]>;
+}
+
+export function purchase(options: PurchaseOptions): Promise<ExpoNamiIapTransaction> {
+  return NativeModule.purchase(options) as Promise<ExpoNamiIapTransaction>;
+}
+
+export function restorePurchases(): Promise<ExpoNamiIapTransaction[]> {
+  return NativeModule.restorePurchases() as Promise<ExpoNamiIapTransaction[]>;
+}
+
+export function finishTransaction(transactionId: string): Promise<void> {
+  return NativeModule.finishTransaction(transactionId);
+}
+
+/**
+ * Subscribe to real-time transaction updates from the native layer.
+ * Returns a subscription object with a `remove()` method to unsubscribe.
+ */
+export function addTransactionListener(
+  cb: (tx: ExpoNamiIapTransaction) => void,
+): { remove: () => void } {
+  return emitter.addListener('onTransactionUpdate', cb);
+}
+
+/**
+ * Subscribe to error events from the native layer.
+ * Returns a subscription object with a `remove()` method to unsubscribe.
+ */
+export function addErrorListener(
+  cb: (err: ExpoNamiIapError) => void,
+): { remove: () => void } {
+  return emitter.addListener('onError', cb);
+}

package/src/types.ts

@@ -0,0 +1,46 @@
+import type { NamiProductDetails } from '@namiml/sdk-core';
+
+export interface ExpoNamiIapProduct extends NamiProductDetails {
+  platform_raw?: unknown;
+}
+
+export interface ExpoNamiIapTransaction {
+  skuId: string;
+  transactionId: string;
+  originalTransactionId?: string;
+  receipt?: string;
+  purchaseToken?: string;
+  purchaseTime?: number;
+  isAcknowledged?: boolean;
+}
+
+export type ExpoNamiIapErrorCode =
+  | 'user_cancelled'
+  | 'network'
+  | 'item_unavailable'
+  | 'already_owned'
+  | 'not_allowed'
+  | 'unknown';
+
+export interface ExpoNamiIapError {
+  code: ExpoNamiIapErrorCode;
+  message: string;
+  nativeCode?: string;
+}
+
+export interface EligibilityResult {
+  skuId: string;
+  introEligible: boolean;
+  promoEligible: boolean;
+}
+
+export interface ConfigureOptions {
+  amazon?: { autoRegisterListener?: boolean };
+}
+
+export interface PurchaseOptions {
+  skuId: string;
+  offerId?: string;
+  offerSignature?: string;
+  appAccountToken?: string;
+}