zixflow-reactnative 1.0.0

package/src/customerio-cdp.ts

@@ -0,0 +1,190 @@
+import { CustomerIOInAppMessaging } from './customerio-inapp';
+import { CustomerIOLocation } from './customerio-location';
+import { CustomerIOPushMessaging } from './customerio-push';
+import { NativeLoggerListener } from './native-logger-listener';
+import {
+  default as NativeModule,
+  type Spec as CodegenSpec,
+} from './specs/modules/NativeCustomerIO';
+import {
+  CioLogLevel,
+  MetricEvent,
+  type CioConfig,
+  type CustomAttributes,
+  type IdentifyParams,
+} from './types';
+import type { NativeSDKArgs } from './types/internal';
+import { callNativeModule, ensureNativeModule } from './utils/native-bridge';
+import { assert, validate } from './utils/param-validation';
+
+const packageJson = require('../../package.json');
+
+// Track whether CustomerIO SDK has been initialized to prevent usage before setup
+let _initialized = false;
+
+// Reference to the native CustomerIO Data Pipelines module for SDK operations
+const nativeModule = ensureNativeModule(NativeModule);
+
+// Wrapper function that ensures SDK is initialized before calling native methods
+const withNativeModule = <R>(fn: (native: CodegenSpec) => R): R => {
+  return callNativeModule(nativeModule, fn);
+};
+
+/** @public */
+export class CustomerIO {
+  /** Initialize the CustomerIO SDK with given configuration. */
+  static readonly initialize = async (config: CioConfig) => {
+    assert.config(config);
+
+    if (config.logLevel && config.logLevel !== CioLogLevel.None) {
+      NativeLoggerListener.initialize();
+    }
+
+    const expoVersion = packageJson.expoVersion ?? '';
+    const args: NativeSDKArgs = {
+      packageSource: expoVersion ? 'Expo' : 'ReactNative',
+      packageVersion: expoVersion || packageJson.version || '',
+    };
+
+    const promise = callNativeModule(NativeModule, (native) =>
+      native.initialize(config, args)
+    );
+    return promise.then(() => {
+      _initialized = true;
+    });
+  };
+
+  /** Identify a user to start tracking their activity. Requires userId, traits, or both. */
+  static readonly identify = async ({
+    userId,
+    traits,
+  }: IdentifyParams = {}) => {
+    if (validate.isUndefined(userId) && validate.isUndefined(traits)) {
+      throw new Error('You must provide either userId or traits to identify');
+    }
+
+    assert.string(userId, 'userId', {
+      allowEmpty: false,
+      usage: 'Identify',
+      optional: true,
+    });
+    const normalizedTraits = assert.attributes(traits, 'traits', {
+      usage: 'Identify',
+      optional: true,
+    });
+
+    return withNativeModule<any>((native) =>
+      native.identify({ userId, traits: normalizedTraits })
+    );
+  };
+
+  /** Clear current user identification and stop tracking. */
+  static readonly clearIdentify = async () => {
+    return withNativeModule<any>((native) => native.clearIdentify());
+  };
+
+  /** Track an event with optional properties. */
+  static readonly track = async (
+    name: string,
+    properties?: Record<string, any>
+  ) => {
+    assert.string(name, 'name', { usage: 'Track Event' });
+    const normalizedProps = assert.attributes(properties, 'properties', {
+      usage: 'Track Event',
+      optional: true,
+    });
+
+    return withNativeModule<any>((native) =>
+      native.track(name, normalizedProps)
+    );
+  };
+
+  /** Track a screen view event with optional properties. */
+  static readonly screen = async (
+    title: string,
+    properties?: Record<string, any>
+  ) => {
+    assert.string(title, 'title', { usage: 'Screen' });
+    const normalizedProps = assert.attributes(properties, 'properties', {
+      usage: 'Screen',
+      optional: true,
+    });
+
+    return withNativeModule<any>((native) =>
+      native.screen(title, normalizedProps)
+    );
+  };
+
+  /** Set or update attributes for the currently identified user profile. */
+  static readonly setProfileAttributes = async (
+    attributes: Record<string, any>
+  ) => {
+    const normalizedAttrs = assert.attributes(attributes, 'attributes', {
+      usage: 'Profile',
+    }) as CustomAttributes;
+
+    return withNativeModule<any>((native) =>
+      native.setProfileAttributes(normalizedAttrs)
+    );
+  };
+
+  /** Set attributes for the current device. */
+  static readonly setDeviceAttributes = async (
+    attributes: Record<string, any>
+  ) => {
+    const normalizedAttrs = assert.attributes(attributes, 'attributes', {
+      usage: 'Device',
+    }) as CustomAttributes;
+
+    return withNativeModule<any>((native) =>
+      native.setDeviceAttributes(normalizedAttrs)
+    );
+  };
+
+  /** Register a device token for push notifications. */
+  static readonly registerDeviceToken = async (token: string) => {
+    assert.string(token, 'token', { usage: 'Device' });
+
+    return withNativeModule((native) => native.registerDeviceToken(token));
+  };
+
+  /** Remove the current device token to stop receiving push notifications. */
+  static readonly deleteDeviceToken = async () => {
+    return withNativeModule((native) => native.deleteDeviceToken());
+  };
+
+  /** Track push notification metrics for delivered, opened, or converted events. */
+  static readonly trackMetric = async ({
+    deliveryID,
+    deviceToken,
+    event,
+  }: {
+    deliveryID: string;
+    deviceToken: string;
+    event: MetricEvent;
+  }) => {
+    assert.string(deliveryID, 'deliveryID', { usage: 'Track Metric' });
+    assert.string(deviceToken, 'deviceToken', { usage: 'Track Metric' });
+    assert.string(event, 'event', { usage: 'Track Metric' });
+
+    return withNativeModule((native) =>
+      native.trackMetric(deliveryID, deviceToken, event)
+    );
+  };
+
+  /**
+   * Check if the CustomerIO SDK has been initialized.
+   * @deprecated This method will be removed in a future version. If you need this functionality, please contact us.
+   */
+  static readonly isInitialized = () => _initialized;
+
+  static readonly inAppMessaging = new CustomerIOInAppMessaging();
+  static readonly location = new CustomerIOLocation();
+  static readonly pushMessaging = new CustomerIOPushMessaging();
+}
+
+// Initialize native logger when this module loads to ensure it's always available.
+// Since customerio-cdp.ts is the main SDK entry point and always imported,
+// this guarantees logger initialization even when native-logger-listener.ts
+// isn't directly accessed, also supporting auto-initialization in Expo apps.
+NativeLoggerListener.initNativeLogger();

package/src/customerio-inapp.ts

@@ -0,0 +1,127 @@
+import { type EventSubscription, type TurboModule } from 'react-native';
+import { InlineInAppMessageView } from './components';
+import { NativeLoggerListener } from './native-logger-listener';
+import {
+  NotificationInbox,
+  type NotificationInboxSpec,
+} from './notification-inbox';
+import NativeCustomerIOMessagingInApp, {
+  type Spec as CodegenSpec,
+} from './specs/modules/NativeCustomerIOMessagingInApp';
+import type { InAppMessageEventType } from './types';
+import { callNativeModule, ensureNativeModule } from './utils/native-bridge';
+
+/**
+ * Ensures all methods defined in codegen spec are implemented by the public module
+ *
+ * @internal
+ */
+interface NativeInAppSpec extends Omit<
+  CodegenSpec,
+  keyof TurboModule | NotificationInboxSpec | 'onInAppEventReceived'
+> {}
+
+// Reference to the native CustomerIO Data Pipelines module for SDK operations
+const nativeModule = ensureNativeModule(NativeCustomerIOMessagingInApp);
+
+// Wrapper function that ensures SDK is initialized before calling native methods
+const withNativeModule = <R>(fn: (native: CodegenSpec) => R): R => {
+  return callNativeModule(nativeModule, fn);
+};
+
+/**
+ * Helper class so that registering event listeners is easier for customers.
+ *
+ * @public
+ */
+class CustomerIOInAppMessaging implements NativeInAppSpec {
+  private _notificationInbox?: NotificationInbox;
+
+  registerEventsListener(
+    listener: (event: InAppMessageEvent) => void
+  ): EventSubscription {
+    const emitter = (data: any) => {
+      // Convert raw native payload to InAppMessageEvent
+      const event = new InAppMessageEvent(
+        data.eventType as InAppMessageEventType,
+        data.messageId,
+        data.deliveryId,
+        data.actionValue,
+        data.actionName
+      );
+      listener(event);
+    };
+
+    return withNativeModule((native) => {
+      try {
+        // Register TurboModule event listener and return subscription.
+        // This method is generated by codegen in the native modules.
+        // Wrapped in try-catch due to previous reports of crashes on certain Android architectures.
+        return native.onInAppEventReceived(emitter);
+      } catch (error) {
+        NativeLoggerListener.warn(
+          'Failed to attach in-app event listener:',
+          error
+        );
+        // Return a no-op subscription to maintain backwards compatibility
+        return {
+          remove: () => {},
+          eventType: '',
+          key: 0,
+          subscriber: null as any,
+        } as EventSubscription;
+      }
+    });
+  }
+
+  /**
+   * Dismisses any currently displayed in-app message
+   */
+  dismissMessage() {
+    withNativeModule((native) => native.dismissMessage());
+  }
+
+  /**
+   * Gets the message inbox instance for managing inbox messages
+   *
+   * @returns NotificationInbox instance for fetching and managing inbox messages
+   */
+  inbox(): NotificationInbox {
+    if (!this._notificationInbox) {
+      this._notificationInbox = new NotificationInbox();
+    }
+    return this._notificationInbox;
+  }
+}
+
+/**
+ * Class to hold in-app event attributes.
+ */
+/** @public */
+class InAppMessageEvent {
+  eventType: InAppMessageEventType;
+  messageId: string;
+  deliveryId?: string;
+  actionValue?: string;
+  actionName?: string;
+
+  constructor(
+    eventType: InAppMessageEventType,
+    messageId: string,
+    deliveryId?: string,
+    actionValue?: string,
+    actionName?: string
+  ) {
+    this.eventType = eventType;
+    this.deliveryId = deliveryId;
+    this.messageId = messageId;
+    this.actionValue = actionValue;
+    this.actionName = actionName;
+  }
+}
+
+// Export in-app messaging types and components for simplified imports
+export type { InlineInAppMessageViewProps } from './components';
+export { NotificationInbox } from './notification-inbox';
+export type { InboxMessage, NotificationInboxChangeListener } from './types';
+export { CustomerIOInAppMessaging, InAppMessageEvent, InlineInAppMessageView };

package/src/customerio-location.ts

@@ -0,0 +1,56 @@
+import { type TurboModule } from 'react-native';
+import {
+  default as NativeModule,
+  type Spec as CodegenSpec,
+} from './specs/modules/NativeCustomerIOLocation';
+
+/**
+ * Ensures all methods defined in codegen spec are implemented by the public module
+ *
+ * @internal
+ */
+interface NativeLocationSpec extends Omit<CodegenSpec, keyof TurboModule> {}
+
+// Location is an optional module — NativeModule may be null when location is not enabled.
+// Methods silently no-op when the native module is unavailable, with a one-time dev warning.
+let hasWarnedNotEnabled = false;
+const withNativeModule = (fn: (native: CodegenSpec) => void): void => {
+  if (NativeModule) {
+    fn(NativeModule);
+  } else if (__DEV__ && !hasWarnedNotEnabled) {
+    hasWarnedNotEnabled = true;
+    console.warn(
+      'Customer.io: Location module is not enabled. ' +
+        'To use location features, set customerio_location_enabled=true in ' +
+        'gradle.properties (Android) or add the location subspec to your Podfile (iOS).'
+    );
+  }
+};
+
+/** @public */
+export class CustomerIOLocation implements NativeLocationSpec {
+  /**
+   * Sets the last known location from the host app's existing location system.
+   * Use this when your app already manages location and you want to send that data
+   * to Customer.io without the SDK managing location permissions directly.
+   *
+   * @param latitude - Latitude in degrees, must be between -90 and 90
+   * @param longitude - Longitude in degrees, must be between -180 and 180
+   */
+  setLastKnownLocation(latitude: number, longitude: number): void {
+    return withNativeModule((native) =>
+      native.setLastKnownLocation(latitude, longitude)
+    );
+  }
+
+  /**
+   * Requests a single location update and sends the result to Customer.io.
+   * No-ops if location tracking is disabled or permission is not granted.
+   *
+   * The SDK does not request location permission. The host app must request
+   * runtime permissions and only call this when permission is granted.
+   */
+  requestLocationUpdate(): void {
+    return withNativeModule((native) => native.requestLocationUpdate());
+  }
+}

package/src/customerio-push.ts

@@ -0,0 +1,127 @@
+import { Platform, type TurboModule } from 'react-native';
+import NativeCustomerIOMessagingPush, {
+  type Spec as CodegenSpec,
+} from './specs/modules/NativeCustomerIOMessagingPush';
+import {
+  type CioPushPermissionOptions,
+  CioPushPermissionStatus,
+} from './types';
+import { callNativeModule, ensureNativeModule } from './utils/native-bridge';
+
+/**
+ * Ensures all methods defined in codegen spec are implemented by the public module
+ *
+ * @internal
+ */
+interface NativePushSpec extends Omit<CodegenSpec, keyof TurboModule> {}
+
+// Reference to the native CustomerIO Data Pipelines module for SDK operations
+const nativeModule = ensureNativeModule(NativeCustomerIOMessagingPush);
+
+// Wrapper function that ensures SDK is initialized before calling native methods
+const withNativeModule = <R>(fn: (native: CodegenSpec) => R): R => {
+  return callNativeModule(nativeModule, fn);
+};
+
+/** @public */
+class CustomerIOPushMessaging implements NativePushSpec {
+  /**
+   * Processes push notification received outside the CIO SDK. The method displays notification on
+   * device and tracks CIO metrics for push notification.
+   *
+   * @param message - push payload received from FCM. The payload must contain data payload received in push
+   * notification.
+   * @param handleNotificationTrigger - indicates whether it should display the notification or not.
+   * true (default): The SDK will display the notification and track associated metrics.
+   * false: The SDK will only process the notification to track metrics but will not display any notification.
+   * @returns promise that resolves to boolean indicating if the notification was handled by the SDK or not.
+   */
+  onMessageReceived(
+    message: any,
+    handleNotificationTrigger: boolean = true
+  ): Promise<boolean> {
+    if (Platform.OS === 'ios') {
+      // Since push notifications on iOS work fine with multiple notification services,
+      // We don't need to process them on iOS for now.
+      // Resolving promise to true makes it easier for callers to avoid adding
+      // unnecessary platform specific checks.
+      return Promise.resolve(true);
+    } else {
+      return withNativeModule((native) =>
+        native.onMessageReceived(message, handleNotificationTrigger)
+      );
+    }
+  }
+
+  /**
+   * Handles push notification received when app is background. Since FCM itself displays the notification
+   * when app is background, this method makes it easier to determine whether the notification should be
+   * displayed or not.
+   *
+   * @see [onMessageReceived] for more details
+   */
+  onBackgroundMessageReceived(message: any): Promise<boolean> {
+    return this.onMessageReceived(message, !message.notification);
+  }
+
+  /**
+   * Track push notifications metrics using this method.
+   * Call this method when a user interacts and taps open the push notification.
+   * @param payload - Customer.io payload as received from the push notification
+   */
+  trackNotificationResponseReceived(payload: Object) {
+    // Tracking push notification metrics on Android is handled automatically
+    // through the Google Services API, so there is no need to make a specific call for it.
+    // This method is specific to iOS and works as expected on Android without any additional intervention.
+    if (payload == null || this.isAndroid()) {
+      return;
+    }
+    withNativeModule((native) =>
+      native.trackNotificationResponseReceived(payload)
+    );
+  }
+
+  /**
+   * Track push notifications metrics using this method.
+   * Call this method when a push notification is received.
+   * @param payload - Customer.io payload as received from the push notification
+   */
+  trackNotificationReceived(payload: Object) {
+    // Tracking push notification metrics on Android is handled automatically
+    // through the Google Services API, so there is no need to make a specific call for it.
+    // This method is specific to iOS and works as expected on Android without any additional intervention.
+    if (payload == null || this.isAndroid()) {
+      return;
+    }
+    withNativeModule((native) => native.trackNotificationReceived(payload));
+  }
+
+  /**
+   * Get the registered device token for the app.
+   * @returns Promise with device token as a string, or error if no token is
+   * registered or the method fails to fetch token.
+   */
+  getRegisteredDeviceToken(): Promise<string> {
+    return withNativeModule((native) => native.getRegisteredDeviceToken());
+  }
+
+  showPromptForPushNotifications(
+    options: CioPushPermissionOptions = { ios: { badge: true, sound: true } }
+  ): Promise<CioPushPermissionStatus> {
+    return withNativeModule((native) =>
+      native.showPromptForPushNotifications(options)
+    ).then((status) => status as CioPushPermissionStatus);
+  }
+
+  getPushPermissionStatus(): Promise<CioPushPermissionStatus> {
+    return withNativeModule((native) => native.getPushPermissionStatus()).then(
+      (status) => status as CioPushPermissionStatus
+    );
+  }
+
+  isAndroid(): boolean {
+    return Platform.OS === 'android';
+  }
+}
+
+export { CustomerIOPushMessaging };

package/src/index.ts

@@ -0,0 +1,9 @@
+/**
+ * This file serves as the entry point for the module zixflow-reactnative.
+ *
+ * This SDK is a customized fork of the Customer.io React Native SDK,
+ * optimized for use with the Zixflow platform.
+ */
+
+// Export ONLY the Zixflow-branded API (no backward compatibility with CustomerIO names)
+export * from './zixflow';

package/src/native-logger-listener.ts

@@ -0,0 +1,84 @@
+import NativeCustomerIOLogging from './specs/modules/NativeCustomerIOLogging';
+import { CioLogLevel } from './types';
+import { callNativeModule, ensureNativeModule } from './utils/native-bridge';
+
+// Reference to the native CustomerIO logging module for SDK operations
+const nativeModule = ensureNativeModule(NativeCustomerIOLogging);
+
+// Wrapper function that ensures SDK is initialized before calling native methods
+const withNativeModule = <R>(
+  fn: (native: typeof NativeCustomerIOLogging) => R
+): R => {
+  return callNativeModule(nativeModule, fn);
+};
+
+/* @internal */
+export class NativeLoggerListener {
+  private static isInitialized = false;
+  // Prefix for all CustomerIO log messages
+  private static loggerPrefix = '[CIO] ';
+
+  static async initialize(): Promise<void> {
+    // Prevent multiple registrations of the same log listener
+    if (this.isInitialized) {
+      return Promise.resolve();
+    }
+
+    // Using console.log will log to the JavaScript side but prevent
+    // React Native's default behavior of redirecting logs to the native side.
+    // By doing it asynchronously, we ensure the logs are captured on both
+    // the JavaScript and native ends.
+    const logEvent = async (event: {
+      logLevel: CioLogLevel;
+      message: string;
+    }) => {
+      switch (event.logLevel) {
+        case CioLogLevel.Debug:
+          console.debug(this.loggerPrefix + event.message);
+          break;
+        case CioLogLevel.Info:
+          console.info(this.loggerPrefix + event.message);
+          break;
+        case CioLogLevel.Error:
+          console.error(this.loggerPrefix + event.message);
+          break;
+        default:
+          console.log(this.loggerPrefix + event);
+          break;
+      }
+    };
+
+    const logHandler = (data: any) => {
+      const event = data as { logLevel: CioLogLevel; message: string };
+      logEvent(event);
+    };
+
+    withNativeModule((native) => {
+      try {
+        // Register TurboModule event listener and return subscription.
+        // This method is generated by codegen in the native modules.
+        // Wrapped in try-catch due to previous reports of crashes on certain Android architectures.
+        native.onCioLogEvent(logHandler);
+      } catch (error) {
+        NativeLoggerListener.warn('Failed to attach log listener:', error);
+      }
+    });
+    this.isInitialized = true;
+  }
+
+  // Logs warning messages in development mode only, with CIO prefix
+  static warn(message: string, error?: unknown) {
+    if (__DEV__) {
+      console.warn(this.loggerPrefix + message, error);
+    }
+  }
+
+  // Initializes native logger listener with error handling
+  static initNativeLogger() {
+    try {
+      NativeLoggerListener.initialize();
+    } catch (error) {
+      NativeLoggerListener.warn('Failed to initialize native logger:', error);
+    }
+  }
+}