@bytem/bytem-tracker-app 0.0.6 → 0.0.8

package/dist/src/types.d.ts

@@ -1,10 +1,37 @@
+/**
+ * Configuration for initializing the BytemTracker.
+ */
 export interface TrackerConfig {
+    /** The unique application ID provided by Bytem. */
     appId: string;
+    /** Custom endpoint URL for tracking requests. */
     endpoint?: string;
+    /** Custom path for the API endpoint (default: '/i'). */
     path?: string;
+    /** Enable debug logging for development. */
     debug?: boolean;
+    /** Optional: Manually set a visitor ID. */
     visitorId?: string;
+    /** Optional: Manually set a device ID. */
+    deviceId?: string;
+    /** Optional: App scheme for domain field in tracking. */
+    appScheme?: string;
 }
+/**
+ * Predefined event keys used internally by the SDK.
+ */
+export declare const BytemEventKeys: {
+    nps: string;
+    survey: string;
+    starRating: string;
+    view: string;
+    orientation: string;
+    pushAction: string;
+    action: string;
+};
+/**
+ * Structure containing device information collected by the SDK.
+ */
 export interface DeviceInfo {
     platform: string;
     os: string;
@@ -33,9 +60,15 @@ export interface BaseParams {
     screen_height: number;
     user_agent: string;
 }
+/**
+ * Arbitrary key-value pairs for user properties.
+ */
 export interface UserTraits {
     [key: string]: any;
 }
+/**
+ * Represents a product in the system.
+ */
 export interface Product {
     productId: string;
     name?: string;
@@ -44,6 +77,9 @@ export interface Product {
     category?: string;
     quantity?: number;
 }
+/**
+ * Represents an order (checkout or payment).
+ */
 export interface Order {
     orderId: string;
     total: number;

package/dist/src/types.js

@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytemEventKeys = void 0;
+/**
+ * Predefined event keys used internally by the SDK.
+ */
+exports.BytemEventKeys = {
+    nps: "[CLY]_nps",
+    survey: "[CLY]_survey",
+    starRating: "[CLY]_star_rating",
+    view: "[CLY]_view",
+    orientation: "[CLY]_orientation",
+    pushAction: "[CLY]_push_action",
+    action: "[CLY]_action",
+};

package/dist/test/BytemTracker.test.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const BytemTracker_1 = __importDefault(require("../src/BytemTracker"));
 const storage_1 = require("../src/core/storage");
 const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const types_1 = require("../src/types");
 describe('BytemTracker SDK', () => {
     const mockConfig = {
         appId: 'test-app-id',
@@ -14,71 +15,244 @@ describe('BytemTracker SDK', () => {
     };
     beforeEach(() => {
         jest.clearAllMocks();
-        // Reset singleton instance manually
-        // @ts-ignore
-        BytemTracker_1.default.instance = undefined;
+        // Reset singleton instance state manually
         // @ts-ignore
         BytemTracker_1.default.isInitialized = false;
         // @ts-ignore
-        BytemTracker_1.default.config = null;
+        BytemTracker_1.default.appKey = null;
+        // @ts-ignore
+        BytemTracker_1.default.baseUrl = 'https://tracking.server.bytecon.com';
         // @ts-ignore
         BytemTracker_1.default.visitorId = null;
+        // @ts-ignore
+        BytemTracker_1.default.sessionStarted = false;
+        // @ts-ignore
+        BytemTracker_1.default.lastBeat = null;
+        // @ts-ignore
+        BytemTracker_1.default.trackTime = true;
+        // @ts-ignore
+        BytemTracker_1.default.storedDuration = 0;
+        // @ts-ignore
+        BytemTracker_1.default.lastViewTime = 0;
+        // @ts-ignore
+        BytemTracker_1.default.lastViewStoredDuration = 0;
+        // Clear storage mocks
+        // @ts-ignore
+        async_storage_1.default.clear();
     });
-    it('should initialize correctly', async () => {
-        await BytemTracker_1.default.init(mockConfig);
-        // Verify Storage was checked for Visitor ID
-        expect(async_storage_1.default.getItem).toHaveBeenCalledWith(storage_1.StorageKeys.VISITOR_ID);
-        // Verify Session was initialized (checks storage)
-        expect(async_storage_1.default.getItem).toHaveBeenCalledWith(storage_1.StorageKeys.SESSION_ID);
+    describe('Initialization', () => {
+        it('should initialize correctly', async () => {
+            await BytemTracker_1.default.init(mockConfig);
+            // Verify Storage was checked for Visitor ID
+            expect(async_storage_1.default.getItem).toHaveBeenCalledWith(storage_1.StorageKeys.VISITOR_ID);
+            // Verify Session was initialized (checks storage)
+            expect(async_storage_1.default.getItem).toHaveBeenCalledWith(`${mockConfig.appId}/cly_session`);
+        });
+        it('should use default endpoint when not provided', async () => {
+            await BytemTracker_1.default.init({
+                appId: 'test-app-id',
+                // endpoint is omitted
+                debug: true,
+            });
+            await BytemTracker_1.default.trackEvent('test_event', {});
+            expect(global.fetch).toHaveBeenCalled();
+            const calls = global.fetch.mock.calls;
+            // Check any call, they should all use the default endpoint
+            const url = calls[0][0];
+            expect(url).toBe('https://tracking.server.bytecon.com/i');
+        });
+        it('should override endpoint path when path is configured', async () => {
+            await BytemTracker_1.default.init({
+                appId: 'test-app-id-2',
+                endpoint: 'https://api.example.com/track',
+                path: '/collect',
+                debug: true,
+            });
+            await BytemTracker_1.default.trackEvent('test_event', {});
+            expect(global.fetch).toHaveBeenCalled();
+            const calls = global.fetch.mock.calls;
+            const url = calls[0][0];
+            expect(url).toBe('https://api.example.com/track/collect');
+        });
     });
-    it('should track an event', async () => {
-        // Ensure initialized (singleton persists)
-        await BytemTracker_1.default.init(mockConfig);
-        const eventName = 'test_event';
-        const eventParams = { foo: 'bar' };
-        // @ts-ignore - Accessing private method for testing or just use public track methods
-        // Since track is private, we'll use a public method like trackUser or just trust the public API
-        // Let's use trackUser as a proxy for generic tracking
-        BytemTracker_1.default.trackUser('user-123', { age: 25 });
-        // Wait for async operations if any (track is async but void return in public API might hide it)
-        // In BytemTracker.ts, trackUser calls track, which is async but not awaited by caller.
-        // We need to wait for promises to resolve.
-        await new Promise(resolve => setTimeout(resolve, 0));
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-        const fetchCall = global.fetch.mock.calls[0];
-        const url = fetchCall[0];
-        const options = fetchCall[1];
-        expect(url).toBe(mockConfig.endpoint);
-        expect(options.method).toBe('POST');
-        const body = JSON.parse(options.body);
-        expect(body.app_id).toBe(mockConfig.appId);
-        // expect(body.event).toBe('identify'); 
+    describe('Event Tracking', () => {
+        beforeEach(async () => {
+            await BytemTracker_1.default.init(mockConfig);
+        });
+        it('should track a simple event', async () => {
+            const eventName = 'test_event';
+            const segmentation = { foo: 'bar' };
+            await BytemTracker_1.default.trackEvent(eventName, segmentation);
+            expect(global.fetch).toHaveBeenCalled();
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes('events='));
+            expect(eventCall).toBeDefined();
+            const options = eventCall[1];
+            const body = options.body;
+            expect(body).toContain(`app_key=${mockConfig.appId}`);
+            expect(body).toContain('events=%5B%7B%22key%22%3A%22test_event%22');
+        });
+        it('should track event with count and sum', async () => {
+            const eventName = 'purchase';
+            const count = 3;
+            const sum = 99.99;
+            const segmentation = { item: 'apple' };
+            await BytemTracker_1.default.trackEvent(eventName, segmentation, count, sum);
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes('events='));
+            const body = decodeURIComponent(eventCall[1].body);
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0]).toMatchObject({
+                key: eventName,
+                count: count,
+                sum: sum,
+                segmentation: segmentation
+            });
+        });
+        it('should track event with duration', async () => {
+            const eventName = 'video_watched';
+            const duration = 120; // seconds
+            await BytemTracker_1.default.trackEvent(eventName, {}, 1, undefined, duration);
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes('events='));
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0].dur).toBe(duration);
+        });
+    });
+    describe('Page View Tracking', () => {
+        beforeEach(async () => {
+            await BytemTracker_1.default.init(mockConfig);
+        });
+        it('should track page view', async () => {
+            const pageName = '/home';
+            await BytemTracker_1.default.trackPageview(pageName);
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes(`%22key%22%3A%22${encodeURIComponent(types_1.BytemEventKeys.view)}%22`));
+            expect(eventCall).toBeDefined();
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0].segmentation).toMatchObject({
+                name: pageName,
+                current: pageName,
+                referrer: ''
+            });
+        });
+        it('should track page view with referrer', async () => {
+            const pageName = '/product/123';
+            const referrer = '/home';
+            await BytemTracker_1.default.trackPageview(pageName, referrer);
+            const calls = global.fetch.mock.calls;
+            // Get the last call which should be the page view
+            const eventCall = calls[calls.length - 1];
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0].segmentation).toMatchObject({
+                name: pageName,
+                current: pageName,
+                referrer: referrer
+            });
+        });
+    });
+    describe('User Tracking', () => {
+        beforeEach(async () => {
+            await BytemTracker_1.default.init(mockConfig);
+        });
+        it('should track user details', async () => {
+            const userId = 'user_123';
+            const userTraits = {
+                name: 'John Doe',
+                email: 'john@example.com',
+                custom: {
+                    plan: 'premium'
+                }
+            };
+            await BytemTracker_1.default.trackUser(userId, userTraits);
+            const calls = global.fetch.mock.calls;
+            const userCall = calls.find(call => call[1].body && call[1].body.includes('user_details='));
+            expect(userCall).toBeDefined();
+            const userDetails = JSON.parse(new URLSearchParams(userCall[1].body).get('user_details') || '{}');
+            expect(userDetails).toMatchObject({
+                name: 'John Doe',
+                email: 'john@example.com',
+                custom: {
+                    plan: 'premium',
+                    user_id: userId
+                }
+            });
+        });
     });
-    it('should use default endpoint when not provided', async () => {
-        await BytemTracker_1.default.init({
-            appId: 'test-app-id',
-            // endpoint is omitted
-            debug: true,
-        });
-        BytemTracker_1.default.trackUser('user-123', { age: 25 });
-        await new Promise(resolve => setTimeout(resolve, 0));
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-        const fetchCall = global.fetch.mock.calls[0];
-        const url = fetchCall[0];
-        expect(url).toBe('https://tracking.server.bytecon.com/i');
+    describe('Session Management', () => {
+        beforeEach(async () => {
+            await BytemTracker_1.default.init(mockConfig);
+        });
+        it('should track session start', async () => {
+            await BytemTracker_1.default.trackSessions();
+            const calls = global.fetch.mock.calls;
+            const sessionCall = calls.find(call => call[1].body && call[1].body.includes('begin_session=1'));
+            expect(sessionCall).toBeDefined();
+        });
+        it('should track session end', async () => {
+            // First start session
+            await BytemTracker_1.default.trackSessions();
+            // Then end session
+            await BytemTracker_1.default.endSession(undefined, true); // force=true to bypass cookie check for test
+            const calls = global.fetch.mock.calls;
+            const endSessionCall = calls.find(call => call[1].body && call[1].body.includes('end_session=1'));
+            expect(endSessionCall).toBeDefined();
+            const body = new URLSearchParams(endSessionCall[1].body);
+            expect(body.has('session_duration')).toBe(true);
+        });
     });
-    it('should override endpoint path when path is configured', async () => {
-        await BytemTracker_1.default.init({
-            appId: 'test-app-id-2',
-            endpoint: 'https://api.example.com/track',
-            path: '/collect',
-            debug: true,
-        });
-        BytemTracker_1.default.trackUser('user-456', { age: 30 });
-        await new Promise(resolve => setTimeout(resolve, 0));
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-        const fetchCall = global.fetch.mock.calls[0];
-        const url = fetchCall[0];
-        expect(url).toBe('https://api.example.com/collect');
+    describe('E-commerce Tracking', () => {
+        beforeEach(async () => {
+            await BytemTracker_1.default.init(mockConfig);
+        });
+        it('should track checkout order', async () => {
+            const order = {
+                orderId: 'order_123',
+                total: 99.99,
+                currency: 'USD',
+                products: [
+                    { productId: 'prod_1', price: 50, quantity: 1 },
+                    { productId: 'prod_2', price: 49.99, quantity: 1 }
+                ]
+            };
+            await BytemTracker_1.default.trackCheckOutOrder(order);
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes('events='));
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0].key).toBe('check_out_order');
+            expect(events[0].segmentation).toMatchObject({
+                order_id: 'order_123',
+                total: 99.99,
+                currency: 'USD',
+                gids: ['prod_1', 'prod_2'],
+                prices: [50, 49.99],
+                quantity: [1, 1]
+            });
+        });
+        it('should track pay order', async () => {
+            const order = {
+                orderId: 'order_123',
+                total: 99.99,
+                currency: 'USD',
+                products: [
+                    { productId: 'prod_1', name: 'Product 1', price: 50, quantity: 1 },
+                    { productId: 'prod_2', name: 'Product 2', price: 49.99, quantity: 2 }
+                ]
+            };
+            await BytemTracker_1.default.trackPayOrder(order);
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes('events='));
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0].key).toBe('pay_order');
+            expect(events[0].segmentation).toMatchObject({
+                order_id: 'order_123',
+                total: 99.99,
+                currency: 'USD',
+                goods: [
+                    { gid: 'prod_1', name: 'Product 1', price: 50, quantity: 1 },
+                    { gid: 'prod_2', name: 'Product 2', price: 49.99, quantity: 2 }
+                ]
+            });
+        });
     });
 });

package/dist/test/debug.test.js

@@ -13,7 +13,22 @@ describe('Debug Scenarios', () => {
     };
     beforeEach(async () => {
         jest.clearAllMocks();
+        // Reset singleton instance state manually
+        // @ts-ignore
+        BytemTracker_1.default.isInitialized = false;
+        // @ts-ignore
+        BytemTracker_1.default.appKey = null;
+        // @ts-ignore
+        BytemTracker_1.default.baseUrl = 'https://tracking.server.bytecon.com';
+        // @ts-ignore
+        BytemTracker_1.default.visitorId = null;
+        // @ts-ignore
+        BytemTracker_1.default.sessionStarted = false;
+        // @ts-ignore
+        BytemTracker_1.default.lastBeat = null;
         // Simulate fresh start
+        // @ts-ignore
+        async_storage_1.default.clear();
         async_storage_1.default.getItem.mockResolvedValue(null);
         await BytemTracker_1.default.init(mockConfig);
     });
@@ -48,11 +63,28 @@ describe('Debug Scenarios', () => {
         });
         await new Promise(resolve => setTimeout(resolve, 0));
         // Assertions to verify flow
-        expect(global.fetch).toHaveBeenCalledTimes(3);
+        // Expect 4 calls: begin_session, view_product, user_details, check_out_order
+        expect(global.fetch).toHaveBeenCalledTimes(4);
         const calls = global.fetch.mock.calls;
-        // Check Event Types
-        const events = calls.map((call) => JSON.parse(call[1].body).event);
-        console.log('>>> Captured Events:', events);
-        expect(events).toEqual(['view_product', 'identify', 'checkout_order']);
+        // Check Request Types
+        const requestTypes = calls.map((call) => {
+            const body = call[1].body;
+            if (body.includes('begin_session=1'))
+                return 'begin_session';
+            if (body.includes('user_details='))
+                return 'identify';
+            if (body.includes('events=')) {
+                // Extract event key
+                const match = body.match(/events=(.*?)($|&)/);
+                if (match) {
+                    const eventsJson = decodeURIComponent(match[1]);
+                    const events = JSON.parse(eventsJson);
+                    return events[0].key;
+                }
+            }
+            return 'unknown';
+        });
+        console.log('>>> Captured Requests:', requestTypes);
+        expect(requestTypes).toEqual(['begin_session', 'view_product', 'identify', 'check_out_order']);
     });
 });

package/dist/test/setup.js

@@ -53,4 +53,5 @@ global.fetch = jest.fn(() => Promise.resolve({
     status: 200,
     statusText: 'OK',
     json: () => Promise.resolve({}),
+    text: () => Promise.resolve('{"status":"success"}'),
 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytem/bytem-tracker-app",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Bytem Tracker SDK for React Native",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",