@amplytools/react-native-amply-sdk 0.9.1 → 0.10.1

package/ios/Sources/AmplyReactNative/AmplyReactNative/AmplyReactNative-generated.mm

@@ -72,6 +72,10 @@ namespace facebook::react {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "registerGate", @selector(registerGate:onAbort:timeoutMs:), args, count);
     }
 
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_unregisterGate(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "unregisterGate", @selector(unregisterGate:), args, count);
+    }
+
     static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "getRecentEvents", @selector(getRecentEvents:resolve:reject:), args, count);
     }
@@ -141,6 +145,9 @@ namespace facebook::react {
         methodMap_["registerGate"] = MethodMetadata {3, __hostFunction_NativeAmplyModuleSpecJSI_registerGate};
         
         
+        methodMap_["unregisterGate"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_unregisterGate};
+        
+        
         methodMap_["getRecentEvents"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents};
         
         

package/ios/Sources/AmplyReactNative/AmplyReactNative/AmplyReactNative.h

@@ -89,6 +89,7 @@ namespace JS {
 - (void)registerGate:(NSString *)baseUrl
              onAbort:(NSString *)onAbort
            timeoutMs:(double)timeoutMs;
+- (void)unregisterGate:(NSString *)baseUrl;
 - (void)getRecentEvents:(double)limit
                 resolve:(RCTPromiseResolveBlock)resolve
                  reject:(RCTPromiseRejectBlock)reject;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amplytools/react-native-amply-sdk",
-  "version": "0.9.1",
+  "version": "0.10.1",
   "description": "React Native SDK for Amply: Mobile SDK to orchestrate in-app experiences and campaigns remotely, without app releases",
   "license": "MIT",
   "repository": {

package/scripts/check-spec-parity.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+#
+# Every method on the TS `Spec` interface must also exist in the three hand-written native
+# specs, or JS calls it and nothing happens.
+#
+# This repo has no codegenConfig: the TurboModule specs are written by hand and committed.
+# Android fails loudly when they drift — the Kotlin module stops overriding an abstract method
+# and the build breaks. iOS does not fail at all. The .mm implementation compiles fine on its
+# own; the method simply never reaches the JSI method map, so the JS call is a silent no-op.
+#
+# That is how `unregisterGate` shipped half-wired in the first pass of the gate-lifecycle work:
+# TS spec, Android spec, both implementations, a clean clang syntax check — and an iOS binding
+# that did not exist. Caught in review, not by any check. This is that check.
+#
+# Usage: bash scripts/check-spec-parity.sh
+set -uo pipefail
+
+cd "$(dirname "$0")/.."
+
+TS_SPEC="src/nativeSpecs/NativeAmplyModule.ts"
+ANDROID_SPEC="android/src/newarch/java/tools/amply/sdk/reactnative/NativeAmplyModuleSpec.java"
+ANDROID_JNI="android/src/newarch/jni/AmplyReactNative-generated.cpp"
+IOS_HEADER="ios/Sources/AmplyReactNative/AmplyReactNative/AmplyReactNative.h"
+IOS_GENERATED="ios/Sources/AmplyReactNative/AmplyReactNative/AmplyReactNative-generated.mm"
+
+for f in "$TS_SPEC" "$ANDROID_SPEC" "$ANDROID_JNI" "$IOS_HEADER" "$IOS_GENERATED"; do
+  if [ ! -f "$f" ]; then
+    echo "check-spec-parity: FAIL — missing $f" >&2
+    exit 1
+  fi
+done
+
+# Method names from the TS `Spec` interface body: lines like `  name(args): Ret;` at one level
+# of indentation, excluding comments and the interface line itself.
+methods=$(
+  awk '/^export interface Spec extends TurboModule \{/{inside=1; next}
+       inside && /^\}/{inside=0}
+       inside' "$TS_SPEC" |
+  grep -oE '^  [a-zA-Z][a-zA-Z0-9_]*\(' |
+  tr -d ' (' |
+  sort -u
+)
+
+if [ -z "$methods" ]; then
+  echo "check-spec-parity: FAIL — parsed zero methods from $TS_SPEC; the parser is broken" >&2
+  exit 1
+fi
+
+fail=0
+for m in $methods; do
+  # addListener/removeListeners are the RN event-emitter contract, supplied by the base class
+  # on iOS rather than declared per-module.
+  case "$m" in
+    addListener|removeListeners) continue ;;
+  esac
+
+  grep -q "abstract .*[ *]$m(" "$ANDROID_SPEC" || {
+    echo "check-spec-parity: $m is in the TS spec but NOT abstract in $ANDROID_SPEC" >&2
+    fail=1
+  }
+  grep -qE "^- \(.*\)$m[:;]" "$IOS_HEADER" || {
+    echo "check-spec-parity: $m is in the TS spec but NOT declared in $IOS_HEADER" >&2
+    fail=1
+  }
+  # The method maps are what actually decide whether JS can reach it. BOTH platforms have one,
+  # and both are hand-maintained here — Android's Java abstract spec is not enough on its own.
+  for map in "$IOS_GENERATED" "$ANDROID_JNI"; do
+    grep -q "methodMap_\[\"$m\"\]" "$map" || {
+      echo "check-spec-parity: $m is in the TS spec but NOT in the JSI methodMap_ in $map" >&2
+      echo "                   → JS would call it and nothing would happen, silently." >&2
+      fail=1
+    }
+  done
+done
+
+if [ "$fail" -ne 0 ]; then
+  echo "check-spec-parity: FAIL" >&2
+  exit 1
+fi
+
+count=$(echo "$methods" | wc -w | tr -d ' ')
+echo "check-spec-parity: OK — all $count TS spec methods are wired on both platforms."

package/src/__tests__/campaignResolved.test.ts

@@ -26,6 +26,7 @@ const mockNativeModule = {
   getDataSetSnapshot: jest.fn(),
   registerDeepLinkListener: jest.fn(),
   registerGate: jest.fn(),
+  unregisterGate: jest.fn(),
   addListener: jest.fn(),
   removeListeners: jest.fn(),
   onSystemEvent: jest.fn(),
@@ -133,7 +134,7 @@ describe('Amply gate API (trackGated + registerGate)', () => {
   });
 
   describe('registerGate', () => {
-    it('registers once on the native module per baseUrl and subscribes to onCampaignPresent', async () => {
+    it('registers on the native module and subscribes to onCampaignPresent', async () => {
       const remove = jest.fn();
       mockNativeModule.onCampaignPresent.mockReturnValue({remove});
 
@@ -144,12 +145,29 @@ describe('Amply gate API (trackGated + registerGate)', () => {
       expect(mockNativeModule.registerGate).toHaveBeenCalledWith('stillframe://ad', 'cancel', 0);
       expect(mockNativeModule.onCampaignPresent).toHaveBeenCalledTimes(1);
 
-      // Second registration of the same baseUrl re-subscribes but does NOT re-register.
-      await Amply.registerGate('stillframe://ad', jest.fn());
-      expect(mockNativeModule.registerGate).toHaveBeenCalledTimes(1);
-
       unsubscribe();
       expect(remove).toHaveBeenCalledTimes(1);
+      expect(mockNativeModule.unregisterGate).toHaveBeenCalledWith('stillframe://ad');
+    });
+
+    // This used to assert the opposite — that a second registration re-subscribed but did
+    // NOT re-register natively. That encoded the defect: the second subscriber joined the
+    // shared onCampaignPresent channel while the first stayed on it, so one presentation was
+    // handed to both presenters, and the second call's onAbort/timeout were silently dropped.
+    // See https://trello.com/c/Gq589zwz; the full behaviour is covered in
+    // gateRegistrationLifecycle.test.ts.
+    it('replaces the previous registration when the same baseUrl is registered again', async () => {
+      mockNativeModule.onCampaignPresent.mockReturnValue({remove: jest.fn()});
+
+      await Amply.registerGate('stillframe://ad', jest.fn());
+      await Amply.registerGate('stillframe://ad', jest.fn(), {timeoutMs: 5000});
+
+      expect(mockNativeModule.unregisterGate).toHaveBeenCalledWith('stillframe://ad');
+      expect(mockNativeModule.registerGate).toHaveBeenLastCalledWith(
+        'stillframe://ad',
+        'cancel',
+        5000,
+      );
     });
 
     it('passes through onAbort and timeoutMs options', async () => {

package/src/__tests__/gateRegistrationLifecycle.test.ts

@@ -0,0 +1,281 @@
+import * as Amply from '../index';
+import {__setNativeModule} from '../nativeModule';
+
+type CampaignPresentEvent = {
+  url: string;
+  params: Record<string, unknown>;
+  info: Record<string, unknown>;
+  mediationId: string;
+};
+
+async function flushMicrotasks(): Promise<void> {
+  for (let i = 0; i < 5; i++) {
+    await Promise.resolve();
+  }
+}
+
+/**
+ * The registration lifecycle of a gate: who receives a presentation, what withdrawal
+ * actually withdraws, and what happens to a registration made before the SDK is up.
+ *
+ * All three were found on 2026-07-31 — the first two by reading the bridge after a field
+ * report on Happens, the third by the field report itself. They share one cause: the JS side
+ * keeps its own record of what is registered natively, and that record was written
+ * optimistically and never reconciled.
+ *
+ * Trello: gate eviction https://trello.com/c/Gq589zwz, withdrawal
+ * https://trello.com/c/saf8I9c6, pre-init registration https://trello.com/c/TZCixnYi
+ */
+describe('gate registration lifecycle', () => {
+  /** Every listener currently attached to the shared onCampaignPresent channel. */
+  let emitters: Array<(e: CampaignPresentEvent) => void>;
+
+  const mockNativeModule = {
+    initialize: jest.fn(),
+    isInitialized: jest.fn(() => true),
+    track: jest.fn(),
+    trackGated: jest.fn(),
+    resolveCampaign: jest.fn(),
+    getRecentEvents: jest.fn(),
+    getDataSetSnapshot: jest.fn(),
+    registerDeepLinkListener: jest.fn(),
+    registerGate: jest.fn(),
+    unregisterGate: jest.fn(),
+    addListener: jest.fn(),
+    removeListeners: jest.fn(),
+    onSystemEvent: jest.fn(),
+    onDeepLink: jest.fn(),
+    onCampaignPresent: jest.fn(),
+    setCustomProperties: jest.fn(),
+    getCustomProperty: jest.fn(),
+    removeCustomProperty: jest.fn(),
+    clearCustomProperties: jest.fn(),
+  };
+
+  beforeEach(() => {
+    emitters = [];
+    mockNativeModule.isInitialized.mockReturnValue(true);
+    mockNativeModule.onCampaignPresent.mockImplementation(
+      (listener: (e: CampaignPresentEvent) => void) => {
+        emitters.push(listener);
+        // `remove` must actually detach, as a real RN subscription does — otherwise this
+        // harness reports a listener as live after it was removed, and every eviction and
+        // withdrawal assertion below would be measuring the mock rather than the code.
+        const remove = jest.fn(() => {
+          const at = emitters.indexOf(listener);
+          if (at >= 0) {
+            emitters.splice(at, 1);
+          }
+        });
+        return {remove};
+      },
+    );
+    mockNativeModule.onDeepLink.mockReturnValue({remove: jest.fn()});
+    __setNativeModule(mockNativeModule as never);
+  });
+
+  afterEach(() => {
+    Amply.removeAllListeners();
+    jest.clearAllMocks();
+    __setNativeModule(null);
+  });
+
+  /** Delivers one presentation to every listener currently subscribed to the channel. */
+  function emitPresentation(mediationId = 'm1'): void {
+    const event: CampaignPresentEvent = {
+      url: 'stillframe://ad?adUnit=main',
+      params: {adUnit: 'main'},
+      info: {campaignId: 'c1'},
+      mediationId,
+    };
+    emitters.forEach(emit => emit(event));
+  }
+
+  describe('a second registration on the same baseUrl (Gq589zwz)', () => {
+    it('leaves exactly one live presenter, not two', async () => {
+      const first = jest.fn((_p, _i, r: Amply.GateResolution) => r.completed());
+      const second = jest.fn((_p, _i, r: Amply.GateResolution) => r.completed());
+
+      await Amply.registerGate('stillframe://ad', first);
+      await Amply.registerGate('stillframe://ad', second);
+
+      emitPresentation();
+      await flushMicrotasks();
+
+      // Both presenters showing UI for one presentation is the defect: the outcome is then
+      // decided by whichever reported first, and the loser's UI is orphaned on screen.
+      expect(second).toHaveBeenCalledTimes(1);
+      expect(first).not.toHaveBeenCalled();
+    });
+
+    it('applies the options of the newest registration', async () => {
+      await Amply.registerGate('stillframe://ad', jest.fn(), {
+        onAbort: 'cancel',
+        timeoutMs: 1000,
+      });
+      await Amply.registerGate('stillframe://ad', jest.fn(), {
+        onAbort: 'proceed',
+        timeoutMs: 8000,
+      });
+
+      // Previously the second call was a no-op natively, so its onAbort and timeout were
+      // silently discarded and the gate kept running under the first call's policy.
+      expect(mockNativeModule.registerGate).toHaveBeenLastCalledWith(
+        'stillframe://ad',
+        'proceed',
+        8000,
+      );
+    });
+
+    it('keeps gates on different baseUrls independent', async () => {
+      const ad = jest.fn((_p, _i, r: Amply.GateResolution) => r.completed());
+      const paywall = jest.fn((_p, _i, r: Amply.GateResolution) => r.completed());
+
+      await Amply.registerGate('stillframe://ad', ad);
+      await Amply.registerGate('stillframe://paywall', paywall);
+
+      emitPresentation();
+      await flushMicrotasks();
+
+      // Only the URL-matching presenter runs; evicting by baseUrl must not evict a sibling.
+      expect(ad).toHaveBeenCalledTimes(1);
+      expect(paywall).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('withdrawal (saf8I9c6)', () => {
+    it('withdraws the native gate, not just the JS subscription', async () => {
+      const unsubscribe = await Amply.registerGate('stillframe://ad', jest.fn());
+
+      unsubscribe();
+
+      // Without this the gate outlives its presenter and parks the next gated call on that
+      // URL for the whole fail-open timeout — silently, with no crash and no console trace.
+      expect(mockNativeModule.unregisterGate).toHaveBeenCalledWith('stillframe://ad');
+    });
+
+    it('lets the same baseUrl be registered again after withdrawal', async () => {
+      const unsubscribe = await Amply.registerGate('stillframe://ad', jest.fn());
+      unsubscribe();
+
+      const presenter = jest.fn((_p, _i, r: Amply.GateResolution) => r.completed());
+      await Amply.registerGate('stillframe://ad', presenter);
+
+      emitPresentation();
+      await flushMicrotasks();
+
+      expect(presenter).toHaveBeenCalledTimes(1);
+    });
+
+    /**
+     * Found by codex, not by me. Withdrawal was keyed by URL alone, so an unsubscribe handed
+     * out for a registration that has since been evicted still withdrew whatever holds that
+     * URL now — killing its replacement. A stale handle must be inert, not destructive.
+     */
+    it('an evicted registration\'s unsubscribe does not withdraw its replacement', async () => {
+      const withdrawFirst = await Amply.registerGate('stillframe://ad', jest.fn());
+
+      const second = jest.fn((_p, _i, r: Amply.GateResolution) => r.completed());
+      await Amply.registerGate('stillframe://ad', second);
+      mockNativeModule.unregisterGate.mockClear();
+
+      withdrawFirst();
+
+      expect(mockNativeModule.unregisterGate).not.toHaveBeenCalled();
+
+      emitPresentation();
+      await flushMicrotasks();
+      expect(second).toHaveBeenCalledTimes(1);
+    });
+
+    it('is idempotent — a second call withdraws nothing further', async () => {
+      const unsubscribe = await Amply.registerGate('stillframe://ad', jest.fn());
+
+      unsubscribe();
+      unsubscribe();
+
+      expect(mockNativeModule.unregisterGate).toHaveBeenCalledTimes(1);
+    });
+
+    it('removeAllListeners withdraws every native gate too', async () => {
+      await Amply.registerGate('stillframe://ad', jest.fn());
+      await Amply.registerGate('stillframe://paywall', jest.fn());
+
+      Amply.removeAllListeners();
+
+      // It used to clear the JS bookkeeping only, leaving JS believing nothing was
+      // registered while both gates were still live natively.
+      expect(mockNativeModule.unregisterGate).toHaveBeenCalledWith('stillframe://ad');
+      expect(mockNativeModule.unregisterGate).toHaveBeenCalledWith('stillframe://paywall');
+    });
+  });
+
+  describe('registration before initialize (TZCixnYi)', () => {
+    it('replays a gate registration once the SDK is up', async () => {
+      mockNativeModule.isInitialized.mockReturnValue(false);
+
+      const presenter = jest.fn((_p, _i, r: Amply.GateResolution) => r.completed());
+      await Amply.registerGate('stillframe://ad', presenter);
+
+      // Native refuses while uninitialised; JS must not record that as done.
+      expect(mockNativeModule.registerGate).not.toHaveBeenCalled();
+
+      mockNativeModule.isInitialized.mockReturnValue(true);
+      await Amply.initialize({apiKey: 'k', apiKeySecret: 's'} as never);
+
+      expect(mockNativeModule.registerGate).toHaveBeenCalledWith('stillframe://ad', 'cancel', 0);
+
+      emitPresentation();
+      await flushMicrotasks();
+      expect(presenter).toHaveBeenCalledTimes(1);
+    });
+
+    it('replays a deeplink listener once the SDK is up', async () => {
+      mockNativeModule.isInitialized.mockReturnValue(false);
+
+      await Amply.addDeepLinkListener(jest.fn());
+      expect(mockNativeModule.registerDeepLinkListener).not.toHaveBeenCalled();
+
+      mockNativeModule.isInitialized.mockReturnValue(true);
+      await Amply.initialize({apiKey: 'k', apiKeySecret: 's'} as never);
+
+      expect(mockNativeModule.registerDeepLinkListener).toHaveBeenCalledTimes(1);
+    });
+
+    /**
+     * Found by self-review, not by the original pass. Eviction ran at `registerGate()` time,
+     * but a queued registration is not in the registry yet, so there was nothing to evict —
+     * both attached at replay and the second overwrote the map entry without removing the
+     * first subscription. That is the duplicate-presenter defect again, on the pre-init path.
+     */
+    it('two registrations on one baseUrl before init still leave one live presenter', async () => {
+      mockNativeModule.isInitialized.mockReturnValue(false);
+
+      const first = jest.fn((_p, _i, r: Amply.GateResolution) => r.completed());
+      const second = jest.fn((_p, _i, r: Amply.GateResolution) => r.completed());
+      await Amply.registerGate('stillframe://ad', first);
+      await Amply.registerGate('stillframe://ad', second);
+
+      mockNativeModule.isInitialized.mockReturnValue(true);
+      await Amply.initialize({apiKey: 'k', apiKeySecret: 's'} as never);
+
+      emitPresentation();
+      await flushMicrotasks();
+
+      expect(second).toHaveBeenCalledTimes(1);
+      expect(first).not.toHaveBeenCalled();
+    });
+
+    it('withdrawing a queued gate cancels it instead of replaying it', async () => {
+      mockNativeModule.isInitialized.mockReturnValue(false);
+
+      const unsubscribe = await Amply.registerGate('stillframe://ad', jest.fn());
+      unsubscribe();
+
+      mockNativeModule.isInitialized.mockReturnValue(true);
+      await Amply.initialize({apiKey: 'k', apiKeySecret: 's'} as never);
+
+      expect(mockNativeModule.registerGate).not.toHaveBeenCalled();
+    });
+  });
+});