@purchasely/cordova-plugin-purchasely 5.7.2 → 6.0.0-rc.1

package/README.md

@@ -10,15 +10,19 @@ cordova plugin add @purchasely/cordova-plugin-purchasely
 
 ## Usage
 
+> **Upgrading from 5.x?** See [MIGRATION-v6.md](../MIGRATION-v6.md).
+
 ```js
-Purchasely.startWithAPIKey(
-    'API_KEY',
-    ['Google'], // list of stores for Android, accepted values: Google, Huawei and Amazon
-    null, // your user id
-    Purchasely.LogLevel.DEBUG, // log level, should be warning or error in production
-    Purchasely.RunningMode.full, // running mode
+Purchasely.start(
+    {
+        apiKey: 'API_KEY',
+        stores: [Purchasely.Store.google], // Android stores: Store.google, Store.huawei, Store.amazon
+        appUserId: null, // your user id
+        logLevel: Purchasely.LogLevel.DEBUG, // should be warning or error in production
+        runningMode: Purchasely.RunningMode.full // observer or full (defaults to observer)
+    },
     (isConfigured) => {
-        if(isConfigured) // you can use the SDK like display a paywall or make a purchase
+        if(isConfigured) {} // you can use the SDK like display a paywall or make a purchase
     },
     (error) => {
         console.log(error);
@@ -28,7 +32,7 @@ Purchasely.startWithAPIKey(
 Purchasely.presentPresentationWithIdentifier(
     'my_presentation_id', // may be null
     'my_content_id', // may be null
-    false, //display in fullscreen mode
+    Purchasely.TransitionType.fullScreen, // display mode
     (callback) => {
         console.log(callback);
         if(callback.result == Purchasely.PurchaseResult.CANCELLED) {

package/__tests__/Purchasely.test.js

@@ -97,24 +97,82 @@ describe('Purchasely', () => {
     });
 
     describe('RunningMode', () => {
-      it('should have correct running mode values', () => {
-        expect(Purchasely.RunningMode.paywallObserver).toBe(2);
-        expect(Purchasely.RunningMode.full).toBe(3);
+      it('should expose the Purchasely 6.0 running modes by name', () => {
+        expect(Purchasely.RunningMode.observer).toBe('observer');
+        expect(Purchasely.RunningMode.full).toBe('full');
       });
     });
 
-    describe('PaywallAction', () => {
-      it('should have correct paywall action values', () => {
-        expect(Purchasely.PaywallAction.close).toBe('close');
-        expect(Purchasely.PaywallAction.close_all).toBe('close_all');
-        expect(Purchasely.PaywallAction.login).toBe('login');
-        expect(Purchasely.PaywallAction.navigate).toBe('navigate');
-        expect(Purchasely.PaywallAction.purchase).toBe('purchase');
-        expect(Purchasely.PaywallAction.restore).toBe('restore');
-        expect(Purchasely.PaywallAction.open_presentation).toBe('open_presentation');
-        expect(Purchasely.PaywallAction.open_placement).toBe('open_placement');
-        expect(Purchasely.PaywallAction.promo_code).toBe('promo_code');
-        expect(Purchasely.PaywallAction.web_checkout).toBe('web_checkout');
+    describe('PresentationAction', () => {
+      it('should have correct presentation action values', () => {
+        expect(Purchasely.PresentationAction.close).toBe('close');
+        expect(Purchasely.PresentationAction.close_all).toBe('close_all');
+        expect(Purchasely.PresentationAction.login).toBe('login');
+        expect(Purchasely.PresentationAction.navigate).toBe('navigate');
+        expect(Purchasely.PresentationAction.purchase).toBe('purchase');
+        expect(Purchasely.PresentationAction.restore).toBe('restore');
+        expect(Purchasely.PresentationAction.open_presentation).toBe('open_presentation');
+        expect(Purchasely.PresentationAction.open_placement).toBe('open_placement');
+        expect(Purchasely.PresentationAction.promo_code).toBe('promo_code');
+        expect(Purchasely.PresentationAction.web_checkout).toBe('web_checkout');
+      });
+    });
+
+    describe('InterceptResult', () => {
+      it('should have correct intercept result values', () => {
+        expect(Purchasely.InterceptResult.success).toBe('success');
+        expect(Purchasely.InterceptResult.failed).toBe('failed');
+        expect(Purchasely.InterceptResult.notHandled).toBe('notHandled');
+      });
+    });
+
+    describe('PresentationType', () => {
+      it('should have correct presentation type values', () => {
+        expect(Purchasely.PresentationType.normal).toBe(0);
+        expect(Purchasely.PresentationType.fallback).toBe(1);
+        expect(Purchasely.PresentationType.deactivated).toBe(2);
+        expect(Purchasely.PresentationType.client).toBe(3);
+      });
+    });
+
+    describe('CloseReason', () => {
+      it('should have correct close reason values', () => {
+        expect(Purchasely.CloseReason.button).toBe('button');
+        expect(Purchasely.CloseReason.backSystem).toBe('back_system');
+        expect(Purchasely.CloseReason.programmatic).toBe('programmatic');
+      });
+    });
+
+    describe('TransitionType', () => {
+      it('should have correct transition type values', () => {
+        expect(Purchasely.TransitionType.fullScreen).toBe('fullScreen');
+        expect(Purchasely.TransitionType.modal).toBe('modal');
+        expect(Purchasely.TransitionType.drawer).toBe('drawer');
+        expect(Purchasely.TransitionType.popin).toBe('popin');
+        expect(Purchasely.TransitionType.push).toBe('push');
+        expect(Purchasely.TransitionType.inlinePaywall).toBe('inlinePaywall');
+      });
+    });
+
+    describe('DimensionType', () => {
+      it('should have correct dimension type values', () => {
+        expect(Purchasely.DimensionType.pixel).toBe('pixel');
+        expect(Purchasely.DimensionType.percentage).toBe('percentage');
+      });
+    });
+
+    describe('Store', () => {
+      it('should have correct store values', () => {
+        expect(Purchasely.Store.google).toBe('Google');
+        expect(Purchasely.Store.huawei).toBe('Huawei');
+        expect(Purchasely.Store.amazon).toBe('Amazon');
+      });
+    });
+
+    describe('StorekitVersion', () => {
+      it('should have correct storekit version values', () => {
+        expect(Purchasely.StorekitVersion.storeKit1).toBe('storeKit1');
+        expect(Purchasely.StorekitVersion.storeKit2).toBe('storeKit2');
       });
     });
 
@@ -135,18 +193,39 @@ describe('Purchasely', () => {
   });
 
   describe('start', () => {
-    it('should call exec with correct parameters', () => {
+    it('should call exec with a single options object (with sdkVersion appended)', () => {
       const success = jest.fn();
       const error = jest.fn();
 
-      Purchasely.start('API_KEY', ['GOOGLE'], false, 'user123', 1, 3, success, error);
+      Purchasely.start(
+        {
+          apiKey: 'API_KEY',
+          stores: [Purchasely.Store.google],
+          storeKit1: false,
+          appUserId: 'user123',
+          logLevel: Purchasely.LogLevel.INFO,
+          runningMode: Purchasely.RunningMode.full
+        },
+        success,
+        error
+      );
 
       expect(mockExec).toHaveBeenCalledWith(
         success,
         error,
         'Purchasely',
         'start',
-        ['API_KEY', ['GOOGLE'], false, 'user123', 1, 3, '5.6.2']
+        [
+          {
+            apiKey: 'API_KEY',
+            stores: ['Google'],
+            storeKit1: false,
+            appUserId: 'user123',
+            logLevel: 1,
+            runningMode: 'full',
+            sdkVersion: '5.6.2'
+          }
+        ]
       );
     });
   });
@@ -270,33 +349,56 @@ describe('Purchasely', () => {
     });
   });
 
-  describe('readyToOpenDeeplink', () => {
+  describe('allowDeeplink', () => {
     it('should call exec with correct parameters', () => {
-      Purchasely.readyToOpenDeeplink(true);
+      Purchasely.allowDeeplink(true);
 
       expect(mockExec).toHaveBeenCalledWith(
         expect.any(Function),
         expect.any(Function),
         'Purchasely',
-        'readyToOpenDeeplink',
+        'allowDeeplink',
         [true]
       );
     });
   });
 
-  describe('setDefaultPresentationResultHandler', () => {
+  describe('allowCampaigns', () => {
+    it('should call exec with correct parameters', () => {
+      Purchasely.allowCampaigns(false);
+
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.any(Function),
+        expect.any(Function),
+        'Purchasely',
+        'allowCampaigns',
+        [false]
+      );
+    });
+  });
+
+  describe('setDefaultPresentationDismissHandler', () => {
     it('should call exec with correct parameters', () => {
       const success = jest.fn();
       const error = jest.fn();
 
-      Purchasely.setDefaultPresentationResultHandler(success, error);
+      Purchasely.setDefaultPresentationDismissHandler(success, error);
 
-      expect(mockExec).toHaveBeenCalledWith(success, error, 'Purchasely', 'setDefaultPresentationResultHandler', []);
+      expect(mockExec).toHaveBeenCalledWith(success, error, 'Purchasely', 'setDefaultPresentationDismissHandler', []);
     });
   });
 
   describe('synchronize', () => {
-    it('should call exec with correct parameters', () => {
+    it('should call exec with the provided callbacks', () => {
+      const success = jest.fn();
+      const error = jest.fn();
+
+      Purchasely.synchronize(success, error);
+
+      expect(mockExec).toHaveBeenCalledWith(success, error, 'Purchasely', 'synchronize', []);
+    });
+
+    it('should default callbacks when none provided', () => {
       Purchasely.synchronize();
 
       expect(mockExec).toHaveBeenCalledWith(
@@ -310,69 +412,116 @@ describe('Purchasely', () => {
   });
 
   describe('presentPresentationWithIdentifier', () => {
-    it('should call exec with correct parameters', () => {
+    it('should pass a display-mode string as a transition object', () => {
+      const success = jest.fn();
+      const error = jest.fn();
+
+      Purchasely.presentPresentationWithIdentifier('presentation1', 'content1', Purchasely.TransitionType.drawer, success, error);
+
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.any(Function),
+        error,
+        'Purchasely',
+        'presentPresentationWithIdentifier',
+        ['presentation1', 'content1', { type: 'drawer' }]
+      );
+    });
+
+    it('should normalize a legacy isFullscreen=true to fullScreen', () => {
       const success = jest.fn();
       const error = jest.fn();
 
       Purchasely.presentPresentationWithIdentifier('presentation1', 'content1', true, success, error);
 
       expect(mockExec).toHaveBeenCalledWith(
-        success,
+        expect.any(Function),
         error,
         'Purchasely',
         'presentPresentationWithIdentifier',
-        ['presentation1', 'content1', true]
+        ['presentation1', 'content1', { type: 'fullScreen' }]
+      );
+    });
+
+    it('should pass a full transition object (dimensions/dismissible) through unchanged', () => {
+      const success = jest.fn();
+      const error = jest.fn();
+      const transition = { type: 'drawer', dismissible: false, height: { type: 'percentage', value: 0.8 } };
+
+      Purchasely.presentPresentationWithIdentifier('presentation1', null, transition, success, error);
+
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.any(Function),
+        error,
+        'Purchasely',
+        'presentPresentationWithIdentifier',
+        ['presentation1', null, transition]
       );
     });
   });
 
   describe('presentPresentationForPlacement', () => {
-    it('should call exec with correct parameters', () => {
+    it('should normalize a legacy isFullscreen=false to modal', () => {
       const success = jest.fn();
       const error = jest.fn();
 
       Purchasely.presentPresentationForPlacement('placement1', 'content1', false, success, error);
 
       expect(mockExec).toHaveBeenCalledWith(
-        success,
+        expect.any(Function),
         error,
         'Purchasely',
         'presentPresentationForPlacement',
-        ['placement1', 'content1', false]
+        ['placement1', 'content1', { type: 'modal' }]
       );
     });
   });
 
-  describe('presentProductWithIdentifier', () => {
-    it('should call exec with correct parameters', () => {
+  describe('presentPresentationForDefault', () => {
+    it('should present the default presentation with a transition object', () => {
       const success = jest.fn();
       const error = jest.fn();
 
-      Purchasely.presentProductWithIdentifier('product1', 'presentation1', 'content1', true, success, error);
+      Purchasely.presentPresentationForDefault('content1', Purchasely.TransitionType.fullScreen, success, error);
 
       expect(mockExec).toHaveBeenCalledWith(
-        success,
+        expect.any(Function),
         error,
         'Purchasely',
-        'presentProductWithIdentifier',
-        ['product1', 'presentation1', 'content1', true]
+        'presentPresentationForDefault',
+        ['content1', { type: 'fullScreen' }]
       );
     });
   });
 
-  describe('presentPlanWithIdentifier', () => {
-    it('should call exec with correct parameters', () => {
+  describe('presentation lifecycle callbacks', () => {
+    it('routes presented/closeRequested envelopes to callbacks and the final outcome to success', () => {
       const success = jest.fn();
-      const error = jest.fn();
+      const onPresented = jest.fn();
+      const onCloseRequested = jest.fn();
+
+      Purchasely.presentPresentationForPlacement('p', null, 'fullScreen', success, jest.fn(), { onPresented, onCloseRequested });
 
-      Purchasely.presentPlanWithIdentifier('plan1', 'presentation1', 'content1', false, success, error);
+      const dispatch = mockExec.mock.calls[0][0];
+      dispatch({ event: 'presented', presentation: { screenId: 's' } });
+      dispatch({ event: 'closeRequested' });
+      dispatch({ result: 1, purchaseResult: 'cancelled', closeReason: 'button' });
+
+      expect(onPresented).toHaveBeenCalledWith({ screenId: 's' }, null);
+      expect(onCloseRequested).toHaveBeenCalledTimes(1);
+      expect(success).toHaveBeenCalledWith({ result: 1, purchaseResult: 'cancelled', closeReason: 'button' });
+    });
+  });
+
+  describe('removeDefaultPresentationDismissHandler', () => {
+    it('should call exec with correct parameters', () => {
+      Purchasely.removeDefaultPresentationDismissHandler();
 
       expect(mockExec).toHaveBeenCalledWith(
-        success,
-        error,
+        expect.any(Function),
+        expect.any(Function),
         'Purchasely',
-        'presentPlanWithIdentifier',
-        ['plan1', 'presentation1', 'content1', false]
+        'removeDefaultPresentationDismissHandler',
+        []
       );
     });
   });
@@ -411,34 +560,37 @@ describe('Purchasely', () => {
     });
   });
 
-  describe('presentPresentation', () => {
-    it('should call exec with correct parameters', () => {
+  describe('fetchPresentationForDefault', () => {
+    it('should call exec with both ids null', () => {
       const success = jest.fn();
       const error = jest.fn();
-      const presentation = { id: 'test' };
 
-      Purchasely.presentPresentation(presentation, true, '#FFFFFF', success, error);
+      Purchasely.fetchPresentationForDefault('content1', success, error);
 
       expect(mockExec).toHaveBeenCalledWith(
         success,
         error,
         'Purchasely',
-        'presentPresentation',
-        [presentation, true, '#FFFFFF']
+        'fetchPresentation',
+        [null, null, 'content1']
       );
     });
   });
 
-  describe('presentSubscriptions', () => {
-    it('should call exec with correct parameters', () => {
-      Purchasely.presentSubscriptions();
+  describe('presentPresentation', () => {
+    it('should call exec with a transition object', () => {
+      const success = jest.fn();
+      const error = jest.fn();
+      const presentation = { id: 'test' };
+
+      Purchasely.presentPresentation(presentation, Purchasely.TransitionType.fullScreen, '#FFFFFF', success, error);
 
       expect(mockExec).toHaveBeenCalledWith(
         expect.any(Function),
-        expect.any(Function),
+        error,
         'Purchasely',
-        'presentSubscriptions',
-        []
+        'presentPresentation',
+        [presentation, { type: 'fullScreen' }, '#FFFFFF']
       );
     });
   });
@@ -493,18 +645,18 @@ describe('Purchasely', () => {
     });
   });
 
-  describe('isDeeplinkHandled', () => {
+  describe('handleDeeplink', () => {
     it('should call exec with correct parameters', () => {
       const success = jest.fn();
       const error = jest.fn();
 
-      Purchasely.isDeeplinkHandled('https://example.com/deeplink', success, error);
+      Purchasely.handleDeeplink('https://example.com/deeplink', success, error);
 
       expect(mockExec).toHaveBeenCalledWith(
         success,
         error,
         'Purchasely',
-        'isDeeplinkHandled',
+        'handleDeeplink',
         ['https://example.com/deeplink']
       );
     });
@@ -559,36 +711,113 @@ describe('Purchasely', () => {
     });
   });
 
-  describe('setPaywallActionInterceptor', () => {
-    it('should call exec with correct parameters', () => {
-      const success = jest.fn();
+  // Flush pending microtasks (the interceptor result is reported through a Promise chain).
+  const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+  // Returns the native success callback exec() was given for a registerActionInterceptor(kind).
+  const nativeInterceptorFor = (kind) => {
+    const call = mockExec.mock.calls.find(
+      (c) => c[3] === 'registerActionInterceptor' && c[4][0] === kind
+    );
+    return call && call[0];
+  };
 
-      Purchasely.setPaywallActionInterceptor(success);
+  describe('interceptAction (v6 per-action)', () => {
+    it('registers a native interceptor for the given kind', () => {
+      Purchasely.interceptAction('purchase', jest.fn());
 
       expect(mockExec).toHaveBeenCalledWith(
-        success,
+        expect.any(Function),
         expect.any(Function),
         'Purchasely',
-        'setPaywallActionInterceptor',
-        []
+        'registerActionInterceptor',
+        ['purchase']
+      );
+    });
+
+    it('invokes the handler with (info, parameters) and reports its result', async () => {
+      const handler = jest.fn().mockReturnValue(Purchasely.InterceptResult.success);
+      Purchasely.interceptAction('purchase', handler);
+      const nativeSuccess = nativeInterceptorFor('purchase');
+      mockExec.mockClear();
+
+      const event = {
+        action: 'purchase',
+        callbackId: 'purchase#1',
+        info: { contentId: 'c1' },
+        parameters: { plan: 'p1' },
+      };
+      nativeSuccess(event);
+      await flush();
+
+      expect(handler).toHaveBeenCalledWith(event.info, event.parameters);
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.any(Function),
+        expect.any(Function),
+        'Purchasely',
+        'completeActionInterceptor',
+        ['purchase#1', 'success']
+      );
+    });
+
+    it('ignores events whose action does not match the registered kind', async () => {
+      const handler = jest.fn();
+      Purchasely.interceptAction('restore', handler);
+      const nativeSuccess = nativeInterceptorFor('restore');
+
+      nativeSuccess({ action: 'purchase', callbackId: 'purchase#2' });
+      await flush();
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+
+    it('reports failed when the handler throws', async () => {
+      Purchasely.interceptAction('purchase', () => { throw new Error('boom'); });
+      const nativeSuccess = nativeInterceptorFor('purchase');
+      mockExec.mockClear();
+
+      nativeSuccess({ action: 'purchase', callbackId: 'purchase#3' });
+      await flush();
+
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.any(Function),
+        expect.any(Function),
+        'Purchasely',
+        'completeActionInterceptor',
+        ['purchase#3', 'failed']
       );
     });
   });
 
-  describe('onProcessAction', () => {
-    it('should call exec with correct parameters', () => {
-      Purchasely.onProcessAction(true);
+  describe('removeActionInterceptor', () => {
+    it('unregisters a single kind', () => {
+      Purchasely.removeActionInterceptor('purchase');
 
       expect(mockExec).toHaveBeenCalledWith(
         expect.any(Function),
         expect.any(Function),
         'Purchasely',
-        'onProcessAction',
-        [true]
+        'unregisterActionInterceptor',
+        ['purchase']
       );
     });
   });
 
+  describe('removeAllActionInterceptors', () => {
+    it('unregisters every registered kind', () => {
+      Purchasely.interceptAction('purchase', jest.fn());
+      Purchasely.interceptAction('restore', jest.fn());
+      mockExec.mockClear();
+
+      Purchasely.removeAllActionInterceptors();
+
+      const unregistered = mockExec.mock.calls
+        .filter((c) => c[3] === 'unregisterActionInterceptor')
+        .map((c) => c[4][0]);
+      expect(unregistered).toEqual(expect.arrayContaining(['purchase', 'restore']));
+    });
+  });
+
   describe('userDidConsumeSubscriptionContent', () => {
     it('should call exec with correct parameters', () => {
       Purchasely.userDidConsumeSubscriptionContent();
@@ -651,43 +880,29 @@ describe('Purchasely', () => {
     });
   });
 
-  describe('showPresentation', () => {
-    it('should call exec with correct parameters', () => {
-      Purchasely.showPresentation();
-
-      expect(mockExec).toHaveBeenCalledWith(
-        expect.any(Function),
-        expect.any(Function),
-        'Purchasely',
-        'showPresentation',
-        []
-      );
-    });
-  });
-
-  describe('hidePresentation', () => {
+  describe('closePresentation', () => {
     it('should call exec with correct parameters', () => {
-      Purchasely.hidePresentation();
+      Purchasely.closePresentation();
 
       expect(mockExec).toHaveBeenCalledWith(
         expect.any(Function),
         expect.any(Function),
         'Purchasely',
-        'hidePresentation',
+        'closePresentation',
         []
       );
     });
   });
 
-  describe('closePresentation', () => {
+  describe('backPresentation', () => {
     it('should call exec with correct parameters', () => {
-      Purchasely.closePresentation();
+      Purchasely.backPresentation();
 
       expect(mockExec).toHaveBeenCalledWith(
         expect.any(Function),
         expect.any(Function),
         'Purchasely',
-        'closePresentation',
+        'backPresentation',
         []
       );
     });

package/example/config.xml

@@ -19,16 +19,6 @@
         <allow-intent href="market:*" />
         <preference name="GradlePluginKotlinEnabled" value="true" />
         <preference name="GradlePluginKotlinVersion" value="2.1.21" />
-        <!--<edit-config
-            file="AndroidManifest.xml"
-            target="/manifest/application/activity[@android:name='cordova.plugin.purchasely.PLYProductActivity']"
-            mode="overwrite">
-            <activity
-                android:label="PLYProductActivity"
-                android:name="cordova.plugin.purchasely.PLYProductActivity"
-                android:theme="@style/Theme.Purchasely.Fullscreen">
-            </activity>
-        </edit-config>-->
     </platform>
     <platform name="ios">
         <allow-intent href="itms:*" />