react-native-test-adx 0.1.1

package/lib/module/hooks/useAdaxon.js

@@ -0,0 +1,35 @@
+"use strict";
+
+import { useContext, useMemo } from 'react';
+import { AdaxonSdkError } from "../errors/AdaxonSdkError.js";
+import { AdaxonContext } from "../state/AdaxonContext.js";
+export function useAdaxon() {
+  const value = useContext(AdaxonContext);
+  if (!value) {
+    throw new AdaxonSdkError('INVALID_CONFIG', 'useAdaxon must be used within AdaxonProvider.');
+  }
+  const {
+    sdk,
+    isInitialized,
+    initializationError
+  } = value;
+  const methods = useMemo(() => ({
+    track: sdk.track.bind(sdk),
+    trackBatch: sdk.trackBatch.bind(sdk),
+    enqueueEvent: sdk.enqueueEvent.bind(sdk),
+    processPendingEvents: sdk.processPendingEvents.bind(sdk),
+    logEvent: sdk.logEvent.bind(sdk),
+    trackPurchase: sdk.trackPurchase.bind(sdk),
+    trackAddToCart: sdk.trackAddToCart.bind(sdk),
+    trackLogin: sdk.trackLogin.bind(sdk),
+    trackCompleteRegistration: sdk.trackCompleteRegistration.bind(sdk),
+    loadRecommendations: sdk.loadRecommendations.bind(sdk),
+    showOffer: sdk.showOffer.bind(sdk),
+    setExternalUserId: sdk.setExternalUserId.bind(sdk)
+  }), [sdk]);
+  return {
+    isInitialized,
+    initializationError,
+    ...methods
+  };
+}

package/lib/module/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { AdaxonSdk } from "./AdaxonSdk.js";
+export { AdaxonProvider } from "./components/AdaxonProvider.js";
+export { useAdaxon } from "./hooks/useAdaxon.js";
+export { AdaxonSdk };
+export { AdaxonSdkError } from "./errors/AdaxonSdkError.js";
+export { AdxEvent, AdxParam } from "./services/event/predefined.js";
+export const Adaxon = AdaxonSdk.shared;
+export default AdaxonSdk;

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/platform/android.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { nonEmptyString, setIfPresent } from "../utils/strings.js";
+export function deviceFieldsFromAndroid(constants) {
+  const fields = {};
+  setIfPresent(fields, 'os_version', nonEmptyString(constants.Release));
+  setIfPresent(fields, 'brand', nonEmptyString(constants.Brand));
+  setIfPresent(fields, 'model', nonEmptyString(constants.Model));
+  return fields;
+}

package/lib/module/platform/app.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import { nonEmptyString, setIfPresent } from "../utils/strings.js";
+export function appFieldsFromNative(constants) {
+  const fields = {};
+  setIfPresent(fields, 'package_name', firstNonEmpty(constants.applicationId, constants.bundleId, constants.androidPackage, constants.iosBundleIdentifier));
+  setIfPresent(fields, 'app_version', firstNonEmpty(constants.nativeApplicationVersion, constants.appVersion, constants.nativeAppVersion));
+  return fields;
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const next = nonEmptyString(value);
+    if (next) {
+      return next;
+    }
+  }
+  return undefined;
+}

package/lib/module/platform/ios.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import { nonEmptyString, setIfPresent } from "../utils/strings.js";
+export function deviceFieldsFromIos(constants) {
+  const fields = {
+    brand: 'Apple'
+  };
+  setIfPresent(fields, 'os_version', nonEmptyString(constants.osVersion) ?? nonEmptyString(constants.Version));
+  setIfPresent(fields, 'model', nonEmptyString(constants.model));
+  return fields;
+}

package/lib/module/platform/network.js

@@ -0,0 +1,61 @@
+"use strict";
+
+import { nonEmptyString } from "../utils/strings.js";
+const CONNECTION_TYPES = new Set(['wifi', 'cellular', 'ethernet', 'bluetooth', 'vpn', 'wimax', 'none', 'unknown', 'other']);
+const IPV4_PATTERN = /^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$/;
+function asNativeNetworkState(state) {
+  if (state && typeof state === 'object') {
+    return state;
+  }
+  return undefined;
+}
+function publicIpAddress(value) {
+  const ip = usableIpAddress(value);
+  return ip && !isPrivateIpAddress(ip) ? ip : undefined;
+}
+export function connectionTypeFromNativeState(state) {
+  const type = nonEmptyString(asNativeNetworkState(state)?.type)?.toLowerCase();
+  return type && CONNECTION_TYPES.has(type) ? type : undefined;
+}
+export function ipAddressFromNativeState(state) {
+  const details = asNativeNetworkState(state)?.details;
+  return usableIpAddress(nonEmptyString(details?.ipAddress) ?? nonEmptyString(details?.ip_address));
+}
+export function usableIpAddress(value) {
+  if (!value) {
+    return undefined;
+  }
+  const ip = value.trim();
+  if (IPV4_PATTERN.test(ip)) {
+    return ip;
+  }
+  if (ip.includes(':') && ip.length <= 45 && /^[0-9a-fA-F:.]+$/.test(ip)) {
+    return ip;
+  }
+  return undefined;
+}
+export function isPrivateIpAddress(ip) {
+  const value = ip.trim().toLowerCase();
+  if (value === '::1' || value.startsWith('fe80:') || value.startsWith('fc') || value.startsWith('fd')) {
+    return true;
+  }
+  if (!IPV4_PATTERN.test(value)) {
+    return false;
+  }
+  const octets = value.split('.').map(Number);
+  const first = octets[0] ?? 0;
+  const second = octets[1] ?? 0;
+  return first === 10 || first === 127 || first === 0 || first === 192 && second === 168 || first === 169 && second === 254 || first === 172 && second >= 16 && second <= 31;
+}
+export function parsePublicIpResponse(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return publicIpAddress(nonEmptyString(parsed.ip));
+    } catch {
+      return undefined;
+    }
+  }
+  return publicIpAddress(trimmed);
+}

package/lib/module/platform/reactNative.js

@@ -0,0 +1,78 @@
+"use strict";
+
+import { Linking, NativeModules, Platform } from 'react-native';
+import { nonEmptyString, setIfPresent } from "../utils/strings.js";
+import { readLocaleFields } from "../utils/locale.js";
+import { appFieldsFromNative } from "./app.js";
+import { deviceFieldsFromAndroid } from "./android.js";
+import { deviceFieldsFromIos } from "./ios.js";
+import { connectionTypeFromNativeState, ipAddressFromNativeState, usableIpAddress } from "./network.js";
+export function detectReactNativePlatform() {
+  return Platform.OS === 'ios' || Platform.OS === 'android' ? Platform.OS : 'web';
+}
+function collectFromReactNative(platform) {
+  const device = {
+    platform
+  };
+  if (Platform.OS === 'android') {
+    Object.assign(device, deviceFieldsFromAndroid(Platform.constants));
+  } else if (Platform.OS === 'ios') {
+    Object.assign(device, deviceFieldsFromIos({
+      ...Platform.constants,
+      Version: Platform.Version
+    }));
+  } else {
+    setIfPresent(device, 'os_version', nonEmptyString(Platform.Version));
+  }
+  Object.assign(device, readLocaleFields());
+  return device;
+}
+export const reactNativeDeviceReader = {
+  readDeviceInfo: collectFromReactNative
+};
+export const reactNativeAppInfoReader = {
+  readAppInfo: () => appFieldsFromNative(readNativeAppConstants())
+};
+export const reactNativeNetworkInfoReader = {
+  readNetworkInfo: collectFromNativeNetwork
+};
+export const reactNativeUrlOpener = Linking;
+function readNativeAppConstants() {
+  const modules = NativeModules ?? {};
+  const expoApp = modules.ExpoApplication;
+  const expoConstants = modules.ExponentConstants;
+  const deviceInfo = modules.RNDeviceInfo;
+  return {
+    ...deviceInfo,
+    ...expoConstants,
+    ...expoApp
+  };
+}
+async function readOptionalNative(read) {
+  try {
+    return await read();
+  } catch {
+    return undefined;
+  }
+}
+async function collectFromNativeNetwork() {
+  const network = {};
+  const modules = NativeModules ?? {};
+  const netInfo = modules.RNCNetInfo;
+  const expoNetwork = modules.ExpoNetwork;
+  const getCurrentState = netInfo?.getCurrentState;
+  if (typeof getCurrentState === 'function') {
+    const state = await readOptionalNative(() => getCurrentState(null));
+    setIfPresent(network, 'connection_type', connectionTypeFromNativeState(state));
+    setIfPresent(network, 'ip_address', ipAddressFromNativeState(state));
+  }
+  const getNetworkState = expoNetwork?.getNetworkStateAsync;
+  if (!network.connection_type && typeof getNetworkState === 'function') {
+    setIfPresent(network, 'connection_type', connectionTypeFromNativeState(await readOptionalNative(getNetworkState)));
+  }
+  const getIpAddress = expoNetwork?.getIpAddressAsync;
+  if (!network.ip_address && typeof getIpAddress === 'function') {
+    setIfPresent(network, 'ip_address', usableIpAddress(nonEmptyString(await readOptionalNative(getIpAddress))));
+  }
+  return network;
+}

package/lib/module/platform/types.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export {};

package/lib/module/services/app/AppInfoService.js

@@ -0,0 +1,25 @@
+"use strict";
+
+import { SDK_VERSION } from "../../config/ApiConstants.js";
+export class AppInfoService {
+  constructor(testMode, reader) {
+    this.testMode = testMode;
+    this.reader = reader;
+  }
+  getAppInfo() {
+    if (!this.cached) {
+      this.cached = {
+        ...this.readOptionalFields(),
+        sdk_version: this.testMode ? `${SDK_VERSION}-test` : SDK_VERSION
+      };
+    }
+    return this.cached;
+  }
+  readOptionalFields() {
+    try {
+      return this.reader?.readAppInfo() ?? {};
+    } catch {
+      return {};
+    }
+  }
+}

package/lib/module/services/authentication/AuthenticationService.js

@@ -0,0 +1,26 @@
+"use strict";
+
+import { DEFAULT_TIMEOUT_MS } from "../../config/ApiConstants.js";
+import { AdaxonSdkError } from "../../errors/AdaxonSdkError.js";
+export class AuthenticationService {
+  constructor(config) {
+    this.validateConfig(config);
+    this.appId = config.appId;
+    this.sdkKey = config.sdkKey;
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  validateConfig(config) {
+    if (!config.appId?.trim()) {
+      this.fail('appId is required.');
+    }
+    if (!config.sdkKey?.trim()) {
+      this.fail('sdkKey is required.');
+    }
+    if (config.timeoutMs !== undefined && (!Number.isFinite(config.timeoutMs) || config.timeoutMs <= 0)) {
+      this.fail('timeoutMs must be a positive number.');
+    }
+  }
+  fail(message) {
+    throw new AdaxonSdkError('INVALID_CONFIG', message);
+  }
+}

package/lib/module/services/device/DeviceInfoService.js

@@ -0,0 +1,22 @@
+"use strict";
+
+export class DeviceInfoService {
+  constructor(platform, reader) {
+    this.platform = platform;
+    this.reader = reader;
+  }
+  getDeviceInfo() {
+    if (!this.cached) {
+      try {
+        this.cached = this.reader?.readDeviceInfo(this.platform) ?? {
+          platform: this.platform
+        };
+      } catch {
+        this.cached = {
+          platform: this.platform
+        };
+      }
+    }
+    return this.cached;
+  }
+}

package/lib/module/services/event/BatchProcessor.js

@@ -0,0 +1,64 @@
+"use strict";
+
+import { MAX_BATCH_SIZE } from "../../config/ApiConstants.js";
+import { AdaxonSdkError } from "../../errors/AdaxonSdkError.js";
+const TEMPORARY_FAILURE_CODES = new Set(['NETWORK_ERROR', 'TIMEOUT', 'HTTP_ERROR', 'AUTHENTICATION_ERROR']);
+export class BatchProcessor {
+  constructor(config) {
+    this.queue = config.queue;
+    this.sendBatch = config.sendBatch;
+  }
+  async process() {
+    if (!this.queue.tryAcquireProcessorLock()) {
+      return this.result('already_processing');
+    }
+    let batchesSent = 0;
+    let eventsProcessed = 0;
+    try {
+      while (true) {
+        const events = await this.queue.getNextBatch(MAX_BATCH_SIZE);
+        if (events.length === 0) {
+          return this.result('completed', {
+            batchesSent,
+            eventsProcessed
+          });
+        }
+        try {
+          const response = await this.sendBatch(events.map(event => event.payload));
+          if (response.success !== true) {
+            return this.stopped(batchesSent, eventsProcessed, events);
+          }
+          await this.queue.remove(events);
+          batchesSent += 1;
+          eventsProcessed += events.length;
+        } catch (error) {
+          return this.stopped(batchesSent, eventsProcessed, events, error);
+        }
+      }
+    } catch (error) {
+      return this.stopped(batchesSent, eventsProcessed, undefined, error);
+    } finally {
+      this.queue.releaseProcessorLock();
+    }
+  }
+  stopped(batchesSent, eventsProcessed, events, error) {
+    if (error !== undefined && !(error instanceof AdaxonSdkError && TEMPORARY_FAILURE_CODES.has(error.code))) {
+      console.error('[Adaxon] Batch processor failed unexpectedly', error);
+    }
+    return this.result('stopped', {
+      batchesSent,
+      eventsProcessed,
+      failedQueueIds: events?.map(event => event.queue_id) ?? [],
+      error
+    });
+  }
+  result(status, extra = {}) {
+    return {
+      status,
+      batchesSent: 0,
+      eventsProcessed: 0,
+      failedQueueIds: [],
+      ...extra
+    };
+  }
+}

package/lib/module/services/event/EventBuilder.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import { createUuid } from "../../utils/uuid.js";
+import { nonEmptyString, setIfPresent } from "../../utils/strings.js";
+export class EventBuilder {
+  sessionId = createUuid();
+  constructor(config) {
+    this.config = config;
+    this.externalUserId = config.externalUserId;
+  }
+  setExternalUserId(externalUserId) {
+    this.externalUserId = externalUserId;
+  }
+  async build(input) {
+    const {
+      validator,
+      appId,
+      anonymousId,
+      deviceInfo,
+      appInfo,
+      networkInfo
+    } = this.config;
+    validator.validateTrackInput(input);
+    const user = {
+      anonymous_id: await anonymousId.getAnonymousId()
+    };
+    setIfPresent(user, 'external_user_id', nonEmptyString(this.externalUserId));
+    return {
+      event_id: input.eventId ?? createUuid(),
+      event_name: input.eventName,
+      event_time: input.eventTime ?? new Date().toISOString(),
+      app_id: appId,
+      properties: input.properties ?? {},
+      user,
+      device: deviceInfo.getDeviceInfo(),
+      app: appInfo.getAppInfo(),
+      session: {
+        session_id: this.sessionId
+      },
+      network: await networkInfo.getNetworkInfo()
+    };
+  }
+}

package/lib/module/services/event/EventQueueService.js

@@ -0,0 +1,35 @@
+"use strict";
+
+import { MAX_BATCH_SIZE } from "../../config/ApiConstants.js";
+import { createUuid } from "../../utils/uuid.js";
+const activeProcessors = new Set();
+export class EventQueueService {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  add(payload) {
+    return this.storage.append({
+      queue_id: createUuid(),
+      created_at: Date.now(),
+      payload
+    });
+  }
+  getNextBatch(limit = MAX_BATCH_SIZE) {
+    const size = Math.min(Math.max(0, Math.floor(limit)), MAX_BATCH_SIZE);
+    return this.storage.getNext(size);
+  }
+  remove(events) {
+    return this.storage.remove(events);
+  }
+  tryAcquireProcessorLock() {
+    const lockId = this.storage.lockId;
+    if (activeProcessors.has(lockId)) {
+      return false;
+    }
+    activeProcessors.add(lockId);
+    return true;
+  }
+  releaseProcessorLock() {
+    activeProcessors.delete(this.storage.lockId);
+  }
+}

package/lib/module/services/event/EventService.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import { EVENT_TRACKING_PATH, RECOMMENDATIONS_PATH } from "../../config/ApiConstants.js";
+import { AdaxonSdkError } from "../../errors/AdaxonSdkError.js";
+export class EventService {
+  constructor(config) {
+    this.api = config.api;
+    this.builder = config.builder;
+    this.validator = config.validator;
+  }
+  track(eventName, properties = {}, options = {}) {
+    return this.trackBatch([{
+      eventName,
+      properties,
+      ...options
+    }]);
+  }
+  async trackBatch(events) {
+    this.validator.validateBatch(events);
+    const payloads = await Promise.all(events.map(event => this.builder.build(event)));
+    return this.postEvents(payloads);
+  }
+  sendPayloads(payloads) {
+    this.validator.validateBatch(payloads);
+    return this.postEvents(payloads);
+  }
+  async getRecommendations(input) {
+    const eventPayload = await this.builder.build(input);
+    const payload = {
+      ...eventPayload,
+      event_type: 'recommendation'
+    };
+    const response = await this.api.post(RECOMMENDATIONS_PATH, payload);
+    if (!Array.isArray(response.offers)) {
+      throw new AdaxonSdkError('HTTP_ERROR', 'Adaxon recommendation response is missing the offers array.');
+    }
+    return response;
+  }
+  postEvents(payloads) {
+    return this.api.post(EVENT_TRACKING_PATH, payloads);
+  }
+}

package/lib/module/services/event/normalizeProperties.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import { AdaxonSdkError } from "../../errors/AdaxonSdkError.js";
+import { AdxParam } from "./predefined.js";
+export function normalizeEventValues(values) {
+  if (values === undefined || values === null) {
+    return {};
+  }
+  if (!isPlainObject(values)) {
+    throw new AdaxonSdkError('VALIDATION_ERROR', 'Event values must be a plain object.');
+  }
+  return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
+}
+export function buildPurchaseProperties(params) {
+  return buildCommerceProperties(params, params.amount);
+}
+export function buildAddToCartProperties(params) {
+  return buildCommerceProperties(params, params.price);
+}
+function buildCommerceProperties(params, revenue) {
+  const properties = {
+    ...params
+  };
+  const contentId = params.content_id ?? params.product_id;
+  if (typeof revenue === 'number') {
+    properties[AdxParam.REVENUE] = revenue;
+  }
+  if (typeof params.currency === 'string') {
+    properties[AdxParam.CURRENCY] = params.currency;
+  }
+  if (typeof contentId === 'string') {
+    properties[AdxParam.CONTENT_ID] = contentId;
+  }
+  return properties;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}

package/lib/module/services/event/predefined.js

@@ -0,0 +1,13 @@
+"use strict";
+
+export const AdxEvent = {
+  PURCHASE: 'adx_purchase',
+  ADD_TO_CART: 'adx_add_to_cart',
+  LOGIN: 'adx_login',
+  COMPLETE_REGISTRATION: 'adx_complete_registration'
+};
+export const AdxParam = {
+  REVENUE: 'adx_revenue',
+  CURRENCY: 'adx_currency',
+  CONTENT_ID: 'adx_content_id'
+};

package/lib/module/services/network/ApiClient.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import { BASE_URL } from "../../config/ApiConstants.js";
+import { AdaxonSdkError } from "../../errors/AdaxonSdkError.js";
+export class ApiClient {
+  constructor(config) {
+    this.config = config;
+    const fetchImplementation = config.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (typeof fetchImplementation !== 'function') {
+      throw new AdaxonSdkError('INVALID_CONFIG', 'A fetch implementation is required.');
+    }
+    this.fetchImplementation = fetchImplementation;
+  }
+  async post(path, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
+    try {
+      const response = await this.fetchImplementation(`${BASE_URL}${path}`, {
+        method: 'POST',
+        headers: {
+          'Accept': 'application/json',
+          'Content-Type': 'application/json',
+          'x-sdk-key': this.config.sdkKey
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      const parsedBody = this.parseJson(await response.text());
+      if (!response.ok) {
+        throw AdaxonSdkError.fromHttp(response.status, parsedBody);
+      }
+      if (parsedBody === null) {
+        throw new AdaxonSdkError('HTTP_ERROR', 'Adaxon returned an empty or invalid JSON response.', {
+          status: response.status
+        });
+      }
+      return parsedBody;
+    } catch (error) {
+      if (error instanceof AdaxonSdkError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new AdaxonSdkError('TIMEOUT', 'Adaxon request timed out.', {
+          cause: error
+        });
+      }
+      const detail = AdaxonSdkError.messageOf(error, '');
+      throw new AdaxonSdkError('NETWORK_ERROR', `Unable to reach Adaxon at ${BASE_URL}.${detail ? ` ${detail}` : ''}`, {
+        cause: error
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  parseJson(rawBody) {
+    try {
+      return rawBody ? JSON.parse(rawBody) : null;
+    } catch {
+      return null;
+    }
+  }
+}