@app-brew/appbrew 1.0.0

package/analytics/app-users.ts

@@ -0,0 +1,107 @@
+import { removeUndefined } from '@gauntlet/analytics'
+import { LocalStorage } from '@gauntlet/local-storage'
+import { useAppStore } from '@gauntlet/state'
+import { AppConfig } from '@gauntlet/types'
+import messaging from '@react-native-firebase/messaging'
+import EnvConfig from 'react-native-config'
+
+interface AppUserInterface {
+  email?: string
+  phoneNumber?: string
+  firstName?: string
+  lastName?: string
+  pushToken: string
+  deviceInstanceId: string
+}
+
+export class AppUser {
+  static USER_KEY = 'app-user'
+  static BASE_URL = `${EnvConfig.APP_SERVICE_URL}/users`
+  static USER_EXPIRY_IN_MILLISECONDS = 1000 * 60 * 60 * 24 * 15
+  static USER_PROPERTIES: (keyof AppUserInterface)[] = [
+    'email',
+    'phoneNumber',
+    'firstName',
+    'lastName',
+    'pushToken',
+    'deviceInstanceId',
+  ]
+
+  static async init(config?: AppConfig) {
+    try {
+      this.USER_EXPIRY_IN_MILLISECONDS =
+        config?.settings?.global?.appUserExpiryInMS ||
+        this.USER_EXPIRY_IN_MILLISECONDS
+      const userLoggedIn = useAppStore.getState().user.isUserAuthenticated()
+      if (!userLoggedIn) {
+        await this.updateUser()
+      }
+    } catch (e) {
+      console.log(e)
+    }
+  }
+
+  static async updateUser(user?: any) {
+    const getInstanceId = useAppStore.getState().analytics.getInstanceId
+    const token = await messaging().getToken()
+    if (token) {
+      const updatedUser = {
+        pushToken: token,
+        deviceInstanceId: getInstanceId(),
+        email: user?.email,
+        phoneNumber: user?.phoneNumber,
+        firstName: user?.firstName,
+        lastName: user?.lastName,
+      }
+
+      removeUndefined(updatedUser)
+
+      const userUpdated = this.checkIfUserUpdated(updatedUser)
+      if (userUpdated) {
+        const response = await fetch(`${this.BASE_URL}`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ ...updatedUser, appId: EnvConfig.APP_ID }),
+        })
+        const isUserUpdated = !(await response.json()).error
+        if (isUserUpdated) {
+          this.updateUserInLocalStorage(updatedUser)
+        }
+      }
+    }
+  }
+
+  private static checkIfUserUpdated(updatedUser: AppUserInterface) {
+    const localStorage = LocalStorage.getInstance()
+    const currentUser:
+      | {
+          data: AppUserInterface
+          lastSyncedAt: number
+        }
+      | undefined = localStorage.getJson(this.USER_KEY)
+    if (!currentUser || !currentUser.data || !currentUser.lastSyncedAt) {
+      return true
+    }
+
+    const expired =
+      (currentUser.lastSyncedAt as number) <
+      Date.now() - this.USER_EXPIRY_IN_MILLISECONDS
+
+    const anyChangeInUserProperty = !this.USER_PROPERTIES.every((key) => {
+      return updatedUser[key] === currentUser.data[key]
+    })
+
+    const userUpdated = expired || anyChangeInUserProperty
+    return userUpdated
+  }
+
+  private static updateUserInLocalStorage(updatedUser: AppUserInterface) {
+    const localStorage = LocalStorage.getInstance()
+    localStorage.set(this.USER_KEY, {
+      data: updatedUser,
+      lastSyncedAt: Date.now(),
+    })
+  }
+}

package/analytics/config.dev.ts

@@ -0,0 +1,10 @@
+export const trackerConfig = {
+  android: {
+    firebaseAppId: '1:444706537999:android:11b0d89a996d60c927197a',
+    apiKey: 'SYv0XlMnTBONYAo0KSAiAg',
+  },
+  ios: {
+    firebaseAppId: '1:444706537999:ios:6c7563bcd6e3276227197a',
+    apiKey: '3ip0WZ0xSl-gUSqwVEYaNQ',
+  },
+}

package/analytics/config.ts

@@ -0,0 +1,10 @@
+export const trackerConfig = {
+  android: {
+    firebaseAppId: '1:234880715042:android:56fd9849f0883448913d7b',
+    apiKey: 'c4EGflbiQIeD2wopPukKsg',
+  },
+  ios: {
+    firebaseAppId: '1:234880715042:ios:e602756a2a4e6c0f913d7b',
+    apiKey: '2rzELbueTgORxUF_utePnQ',
+  },
+}

package/analytics/tracker.ts

@@ -0,0 +1,136 @@
+import { AnalyticsEvent, AnalyticsPayload, AppConfig } from '@gauntlet/types'
+import analytics from '@react-native-firebase/analytics'
+import { Platform } from 'react-native'
+import base64 from 'react-native-base64'
+// To push data to dev BigQuery, update the import to: import { trackerConfig } from './config.dev'
+import { trackerConfig } from './config'
+import { useAppStore } from '@gauntlet/state'
+import { execute } from './utils'
+import { AnalyticsTracker, trimParameters } from '@gauntlet/analytics'
+import { AppUser } from './app-users'
+
+export class AppbrewTracker extends AnalyticsTracker {
+  ITEMS_PARAMETER_CHARACTERS_LIMIT = 100
+  BASE_URL = 'https://www.google-analytics.com/mp/collect'
+  appInstanceId: string | null = null
+  instanceId: string | null = null
+  userId: string | undefined = undefined
+  deviceInfo: any = {}
+  appInfo: any = {}
+  geoInfo: any = {}
+  installSourceUtmParams: any = {}
+  userProperties: any = {}
+  config =
+    Platform.OS === 'android' ? trackerConfig['android'] : trackerConfig['ios']
+
+  async initTracker(config?: AppConfig) {
+    try {
+      await AppUser.init(config)
+      const getUserId = useAppStore.getState().analytics.getUserId
+      const getInstanceId = useAppStore.getState().analytics.getInstanceId
+      const getDeviceInfo = useAppStore.getState().analytics.getDeviceInfo
+      const getGeoInfo = useAppStore.getState().analytics.getGeoInfo
+      const getInstallSourceUtmParams =
+        useAppStore.getState().analytics.getInstallSourceUtmParams
+      const getAppInfo = useAppStore.getState().analytics.getAppInfo
+      ;[
+        this.userId,
+        this.appInstanceId,
+        this.instanceId,
+        this.deviceInfo,
+        this.geoInfo,
+        this.installSourceUtmParams,
+        this.appInfo,
+      ] = await Promise.all([
+        execute(getUserId),
+        analytics().getAppInstanceId(),
+        execute(getInstanceId),
+        execute(getDeviceInfo),
+        execute(getGeoInfo),
+        execute(getInstallSourceUtmParams),
+        execute(getAppInfo),
+      ])
+      const { app_name, app_id, ...appInfo } = this.appInfo
+
+      const originalUserProperties = {
+        ...this.geoInfo,
+        ...this.deviceInfo,
+        ...appInfo,
+        ...this.installSourceUtmParams,
+      }
+
+      Object.keys(originalUserProperties).forEach((key) => {
+        this.userProperties[key] = {
+          value: originalUserProperties[key],
+        }
+      })
+    } catch (err) {
+      console.log('Error occurred while getting instance id')
+    }
+  }
+
+  async sendEvent(e: AnalyticsEvent, p: AnalyticsPayload) {
+    this.sendMeasurementEvent(e, p)
+  }
+  async sendScreenView(screenName: string) {
+    this.sendMeasurementEvent(AnalyticsEvent.PAGE_VIEW, { screenName })
+  }
+
+  async setUserDetails(user: any) {
+    this.userId = user?.email && base64.encode(user?.email)
+    await AppUser.updateUser(user)
+  }
+
+  private async sendMeasurementEvent(
+    event: AnalyticsEvent,
+    payload: AnalyticsPayload
+  ) {
+    const formattedPayload = trimParameters(
+      payload,
+      this.ITEMS_PARAMETER_CHARACTERS_LIMIT
+    )
+
+    const getSessionId = useAppStore.getState().analytics.getSessionId
+    const getTriggeredFromPush =
+      useAppStore.getState().analytics.getTriggeredFromPush
+    const sessionId = getSessionId()
+    const triggeredByPush = getTriggeredFromPush()
+    if (this.appInstanceId && this.instanceId && sessionId) {
+      try {
+        const { app_name, app_id } = this.appInfo
+        const eventSourceUtmParams = await useAppStore
+          .getState()
+          .analytics.getEventSourceUtmParams()
+        await fetch(
+          `${this.BASE_URL}?api_secret=${this.config.apiKey}&firebase_app_id=${this.config.firebaseAppId}`,
+          {
+            method: 'POST',
+            body: JSON.stringify({
+              app_instance_id: this.appInstanceId,
+              user_id: this.userId || this.instanceId,
+              non_personalized_ads: true,
+              user_properties: this.userProperties,
+              events: [
+                {
+                  name: event,
+                  params: {
+                    instance_id: this.instanceId,
+                    session_id: sessionId,
+                    appbrew_session_id: sessionId,
+                    triggered_by_push: triggeredByPush,
+                    app_id,
+                    app_name,
+                    ...eventSourceUtmParams,
+                    ...formattedPayload,
+                  },
+                },
+              ],
+            }),
+          }
+        )
+      } catch (err) {
+        // ignore
+      }
+    }
+  }
+}

package/analytics/trackerV2.ts

@@ -0,0 +1,154 @@
+import {
+  AnalyticsEvent,
+  AnalyticsEventParams,
+  AnalyticsPayload,
+  AppConfig,
+} from '@gauntlet/types'
+import analytics from '@react-native-firebase/analytics'
+import { Platform } from 'react-native'
+import base64 from 'react-native-base64'
+// To push data to dev BigQuery, update the import to: import { trackerConfig } from './config.dev'
+import { trackerConfig } from './config'
+import { useAppStore } from '@gauntlet/state'
+import { execute } from './utils'
+import { AnalyticsTrackerV2, trimParameters } from '@gauntlet/analytics'
+import { AppUser } from './app-users'
+
+const defaultEventsWhitelist = Object.values(AnalyticsEvent)
+const defaultParamsWhitelist = Object.values(AnalyticsEventParams)
+
+export class AppbrewTrackerV2 extends AnalyticsTrackerV2 {
+  SESSION_EXPIRY_IN_SECONDS = 30 * 60
+  SESSION_KEY = 'appbrewSession'
+  ITEMS_PARAMETER_CHARACTERS_LIMIT = 100
+  BASE_URL = 'https://www.google-analytics.com/mp/collect'
+  appInstanceId: string | null = null
+  instanceId: string | null = null
+  userId: string | undefined = undefined
+  deviceInfo: any = {}
+  appInfo: any = {}
+  geoInfo: any = {}
+  installSourceUtmParams: any = {}
+  userProperties: any = {}
+  config =
+    Platform.OS === 'android' ? trackerConfig['android'] : trackerConfig['ios']
+
+  async initTracker(config?: AppConfig) {
+    try {
+      await AppUser.init(config)
+
+      this.eventsMapper = {}
+      this.paramsMapper = {}
+      this.eventsWhitelist = defaultEventsWhitelist
+      this.paramsWhitelist = defaultParamsWhitelist
+
+      const getUserId = useAppStore.getState().analytics.getUserId
+      const getInstanceId = useAppStore.getState().analytics.getInstanceId
+      const getDeviceInfo = useAppStore.getState().analytics.getDeviceInfo
+      const getGeoInfo = useAppStore.getState().analytics.getGeoInfo
+      const getInstallSourceUtmParams =
+        useAppStore.getState().analytics.getInstallSourceUtmParams
+      const getAppInfo = useAppStore.getState().analytics.getAppInfo
+      ;[
+        this.userId,
+        this.appInstanceId,
+        this.instanceId,
+        this.deviceInfo,
+        this.geoInfo,
+        this.installSourceUtmParams,
+        this.appInfo,
+      ] = await Promise.all([
+        execute(getUserId),
+        analytics().getAppInstanceId(),
+        execute(getInstanceId),
+        execute(getDeviceInfo),
+        execute(getGeoInfo),
+        execute(getInstallSourceUtmParams),
+        execute(getAppInfo),
+      ])
+      const { app_name, app_id, ...appInfo } = this.appInfo
+
+      const originalUserProperties = {
+        ...this.geoInfo,
+        ...this.deviceInfo,
+        ...appInfo,
+        ...this.installSourceUtmParams,
+      }
+
+      Object.keys(originalUserProperties).forEach((key) => {
+        this.userProperties[key] = {
+          value: originalUserProperties[key],
+        }
+      })
+    } catch (err) {
+      console.log('Error occurred while getting instance id')
+    }
+  }
+
+  async sendEvent(e: AnalyticsEvent, p: AnalyticsPayload) {
+    this.sendMeasurementEvent(e, p)
+  }
+  async sendScreenView(screenName: string) {
+    this.sendMeasurementEvent(AnalyticsEvent.PAGE_VIEW, {
+      [AnalyticsEventParams.SCREEN_NAME]: screenName,
+    })
+  }
+
+  async setUserDetails(user: any) {
+    this.userId = user?.email && base64.encode(user?.email)
+    await AppUser.updateUser(user)
+  }
+
+  private async sendMeasurementEvent(
+    event: AnalyticsEvent,
+    payload: AnalyticsPayload
+  ) {
+    const formattedPayload = trimParameters(
+      payload,
+      this.ITEMS_PARAMETER_CHARACTERS_LIMIT
+    )
+
+    const getSessionId = useAppStore.getState().analytics.getSessionId
+    const getTriggeredFromPush =
+      useAppStore.getState().analytics.getTriggeredFromPush
+    const sessionId = getSessionId()
+    const triggeredByPush = getTriggeredFromPush()
+    if (this.appInstanceId && this.instanceId && sessionId) {
+      try {
+        const { app_name, app_id } = this.appInfo
+        const eventSourceUtmParams = await useAppStore
+          .getState()
+          .analytics.getEventSourceUtmParams()
+        await fetch(
+          `${this.BASE_URL}?api_secret=${this.config.apiKey}&firebase_app_id=${this.config.firebaseAppId}`,
+          {
+            method: 'POST',
+            body: JSON.stringify({
+              app_instance_id: this.appInstanceId,
+              user_id: this.userId || this.instanceId,
+              non_personalized_ads: true,
+              user_properties: this.userProperties,
+              events: [
+                {
+                  name: event,
+                  params: {
+                    instance_id: this.instanceId,
+                    session_id: sessionId,
+                    appbrew_session_id: sessionId,
+                    triggered_by_push: triggeredByPush,
+                    app_id,
+                    app_name,
+                    ...eventSourceUtmParams,
+                    ...formattedPayload,
+                  },
+                },
+              ],
+            }),
+          }
+        )
+      } catch (err) {
+        // ignore
+      }
+    }
+  }
+}

package/analytics/utils.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/react-native'
+export async function execute(func: any) {
+  try {
+    return await func()
+  } catch (e) {
+    console.log(e)
+    Sentry.captureException(e)
+  }
+}

package/analytics/webhook-tracker.ts

@@ -0,0 +1,203 @@
+import {
+  AnalyticsEvent,
+  AnalyticsEventParams,
+  AnalyticsPayload,
+  AppConfig,
+} from '@gauntlet/types'
+import { AnalyticsTrackerV2 } from '@gauntlet/analytics'
+import { useAppStore } from '@gauntlet/state'
+
+export interface WebhookTrackerConfig {
+  apiUrl?: string
+  eventUrls?: Record<string, string>
+  eventsWhitelist?: AnalyticsEvent[]
+  paramsWhitelist?: AnalyticsEventParams[]
+  headers?: Record<string, string>
+}
+
+export class WebhookTracker extends AnalyticsTrackerV2 {
+  private trackerId: string
+  private defaultApiUrl = ''
+  private eventUrls: Record<string, string> = {}
+  private customHeaders: Record<string, string> = {}
+  private userDetails: {
+    email?: string
+    phone?: string
+    firstName?: string
+    lastName?: string
+    customerId?: string
+  } = {}
+  private instanceId: string | null = null
+  private sessionId: string | null = null
+  private deviceInfo: any = {}
+  private appInfo: any = {}
+
+  constructor(trackerId: string) {
+    super()
+    this.trackerId = trackerId
+  }
+
+  override async initTracker(config?: AppConfig) {
+    // Look for config by tracker ID: config.integrations.webhookTrackers[trackerId]
+    const trackerConfig =
+      config?.integrations?.[this.trackerId] ??
+      (config?.integrations?.webhookTrackers?.[this.trackerId] as
+        | WebhookTrackerConfig
+        | undefined)
+
+    if (!trackerConfig) {
+      console.warn(`WebhookTracker [${this.trackerId}]: No config found`)
+      return
+    }
+
+    if (!trackerConfig.apiUrl && !trackerConfig.eventUrls) {
+      console.warn(
+        `WebhookTracker [${this.trackerId}]: No API URL or event URLs configured`
+      )
+      return
+    }
+
+    this.defaultApiUrl = trackerConfig.apiUrl || ''
+    this.eventUrls = trackerConfig.eventUrls || {}
+    this.customHeaders = trackerConfig.headers || {}
+
+    // Set whitelists from config
+    this.eventsWhitelist = trackerConfig.eventsWhitelist || []
+    this.paramsWhitelist = trackerConfig.paramsWhitelist || []
+
+    // Get instance and device info
+    const getInstanceId = useAppStore.getState().analytics.getInstanceId
+    const getDeviceInfo = useAppStore.getState().analytics.getDeviceInfo
+    const getAppInfo = useAppStore.getState().analytics.getAppInfo
+
+    try {
+      const [instanceId, deviceInfo, appInfo] = await Promise.all([
+        getInstanceId(),
+        getDeviceInfo(),
+        getAppInfo(),
+      ])
+
+      this.instanceId = instanceId
+      this.deviceInfo = deviceInfo
+      this.appInfo = appInfo
+    } catch (err) {
+      console.error(
+        `WebhookTracker [${this.trackerId}]: Error initializing tracker`,
+        err
+      )
+    }
+  }
+
+  override async setUserDetails(user: any) {
+    if (user) {
+      this.userDetails = {
+        email: user.email,
+        phone: user.phone || user.phoneNumber,
+        firstName: user.firstName,
+        lastName: user.lastName,
+        customerId: user.id?.replace('gid://shopify/Customer/', ''),
+      }
+    }
+  }
+
+  override async sendEvent(event: AnalyticsEvent, payload: AnalyticsPayload) {
+    const url = this.getUrlForEvent(event)
+
+    if (!url || !event) return
+
+    // Check whitelist - if configured, only send whitelisted events
+    if (
+      this.eventsWhitelist.length > 0 &&
+      !this.eventsWhitelist.includes(event)
+    ) {
+      return
+    }
+
+    try {
+      const getSessionId = useAppStore.getState().analytics.getSessionId
+      this.sessionId = getSessionId()
+
+      const eventPayload = {
+        trackerId: this.trackerId,
+        event,
+        timestamp: new Date().toISOString(),
+        user: this.userDetails,
+        session: {
+          sessionId: this.sessionId,
+          instanceId: this.instanceId,
+        },
+        device: this.deviceInfo,
+        app: this.appInfo,
+        payload,
+      }
+
+      await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...this.customHeaders,
+        },
+        body: JSON.stringify(eventPayload),
+      })
+    } catch (err) {
+      console.error(
+        `WebhookTracker [${this.trackerId}]: Error sending event`,
+        err
+      )
+    }
+  }
+
+  override async sendScreenView(screenName: string) {
+    const url = this.getUrlForEvent(AnalyticsEvent.SCREEN_VIEW)
+
+    if (!url) return
+
+    // Check whitelist - if configured, only send if screen_view is whitelisted
+    if (
+      this.eventsWhitelist.length > 0 &&
+      !this.eventsWhitelist.includes(AnalyticsEvent.SCREEN_VIEW)
+    ) {
+      return
+    }
+
+    try {
+      const getSessionId = useAppStore.getState().analytics.getSessionId
+      this.sessionId = getSessionId()
+
+      const screenViewPayload = {
+        trackerId: this.trackerId,
+        event: AnalyticsEvent.SCREEN_VIEW,
+        timestamp: new Date().toISOString(),
+        user: this.userDetails,
+        session: {
+          sessionId: this.sessionId,
+          instanceId: this.instanceId,
+        },
+        device: this.deviceInfo,
+        app: this.appInfo,
+        payload: {
+          screen_name: screenName,
+        },
+      }
+
+      await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...this.customHeaders,
+        },
+        body: JSON.stringify(screenViewPayload),
+      })
+    } catch (err) {
+      console.error(
+        `WebhookTracker [${this.trackerId}]: Error sending screen view`,
+        err
+      )
+    }
+  }
+
+  private getUrlForEvent(event: string): string | null {
+    // Check for event-specific URL first, then fall back to default
+    return this.eventUrls[event] || this.defaultApiUrl || null
+  }
+}

package/currency/index.ts

@@ -0,0 +1 @@
+export * from './provider'

package/currency/provider.ts

@@ -0,0 +1,211 @@
+import {
+  AppConfig,
+  AsyncData,
+  ConversionRates,
+  Country,
+  CountryCode,
+  CountryCodeToCountryMap,
+  CurrencyCode,
+  CurrencyCodeToSymbolMap,
+  IAvailableCountryResponse,
+  ICurrencyProvider,
+} from '@gauntlet/types'
+import EnvConfig from 'react-native-config'
+
+type Settings = {
+  defaultCountry: string
+  supportedCountries: Array<string>
+}
+
+const BASE_URL = `${EnvConfig['APP_SERVICE_URL']}/integrations/appbrew-currency/conversion-rates`
+export class AppbrewCurrencyProvider implements ICurrencyProvider {
+  static instance: AppbrewCurrencyProvider
+  static country: Country
+  private response: AsyncData<any>
+  private fetchPromise: Promise<any> | undefined
+
+  static getInstance(appConfig: AppConfig): AppbrewCurrencyProvider {
+    if (!AppbrewCurrencyProvider.instance) {
+      AppbrewCurrencyProvider.instance = new AppbrewCurrencyProvider(appConfig)
+    }
+    return AppbrewCurrencyProvider.instance
+  }
+
+  constructor(private readonly appConfig: AppConfig) {
+    this.response = { status: 'init' }
+  }
+
+  async getAvailableCountries(
+    appConfig: AppConfig
+  ): Promise<AsyncData<IAvailableCountryResponse>> {
+    const moduleSettings = getCurrencySettings(appConfig)
+    if (!moduleSettings) {
+      return {
+        status: 'error',
+        error: {
+          message: `Appbrew Currency module not configured`,
+          rootCause:
+            'Appbrew Currency module not configured at getAvailableCountries',
+          code: `APPBREW_CURRENCY_MODULE_NOT_CONFIGURED`,
+        },
+      }
+    }
+    const defaultCountryCode = moduleSettings.defaultCountryCode
+    const supportedCountries = moduleSettings.supportedCountries
+    const currencyCodeMapping = moduleSettings?.currencyCodeMapping // This is an optional mapping for particular country - country code for showing currency, if not provided, it will use the default currency code from CountryCodeToCountryMap
+
+    const availableCountries = supportedCountries?.map((c: string) => {
+      return {
+        isoCode: c as CountryCode,
+        name: CountryCodeToCountryMap[c].countryName,
+        currency: {
+          isoCode:
+            CountryCodeToCountryMap[currencyCodeMapping?.[c]]?.currencyCode ??
+            (CountryCodeToCountryMap[c].currencyCode as CurrencyCode),
+          symbol:
+            CurrencyCodeToSymbolMap[
+              CountryCodeToCountryMap[currencyCodeMapping?.[c]]?.currencyCode
+            ] ??
+            CurrencyCodeToSymbolMap[
+              CountryCodeToCountryMap?.[c].currencyCode
+            ] ??
+            CountryCodeToCountryMap[c].currencyCode,
+          name:
+            CountryCodeToCountryMap[currencyCodeMapping?.[c]]?.currencyCode ??
+            CountryCodeToCountryMap[c].currencyCode,
+        },
+      }
+    })
+    const defaultCountry = {
+      isoCode: defaultCountryCode as CountryCode,
+      name: CountryCodeToCountryMap[defaultCountryCode].countryName,
+      currency: {
+        isoCode: CountryCodeToCountryMap[defaultCountryCode]
+          .currencyCode as CurrencyCode,
+        symbol:
+          CurrencyCodeToSymbolMap[
+            CountryCodeToCountryMap[defaultCountryCode].currencyCode
+          ] ?? CountryCodeToCountryMap[defaultCountryCode].currencyCode,
+        name: CountryCodeToCountryMap[defaultCountryCode].currencyCode,
+      },
+    }
+    AppbrewCurrencyProvider.country = defaultCountry
+
+    const res: AsyncData<IAvailableCountryResponse> = {
+      status: 'idle',
+      data: {
+        availableCountries: availableCountries,
+      },
+    }
+    return res
+  }
+  async updateCountryCode(appConfig: AppConfig, countryCode: CountryCode) {
+    const country = {
+      isoCode: countryCode,
+      name: CountryCodeToCountryMap[countryCode].countryName,
+      currency: {
+        isoCode: CountryCodeToCountryMap[countryCode]
+          .currencyCode as CurrencyCode,
+        symbol:
+          CurrencyCodeToSymbolMap[
+            CountryCodeToCountryMap[countryCode].currencyCode
+          ] ?? CountryCodeToCountryMap[countryCode].currencyCode,
+        name: CountryCodeToCountryMap[countryCode].currencyCode,
+      },
+    }
+    AppbrewCurrencyProvider.country = country
+    return country.isoCode
+  }
+  async getConversionrates(
+    appConfig: AppConfig
+  ): Promise<AsyncData<ConversionRates>> {
+    if (this.response.status === 'idle') return this.response
+    const moduleSettings = getCurrencySettings(appConfig)
+    if (!moduleSettings) {
+      return {
+        status: 'error',
+        error: {
+          message: `Appbrew Currency module not configured`,
+          rootCause:
+            'Appbrew Currency module not configured at getConversionrates',
+          code: `APPBREW_CURRENCY_MODULE_NOT_CONFIGURED`,
+        },
+      }
+    }
+    const defaultCountryCode = moduleSettings.defaultCountryCode
+    const supportedCountries = moduleSettings.supportedCountries
+    const bCurrency = CountryCodeToCountryMap[defaultCountryCode].currencyCode
+    const cCodes = supportedCountries.map(
+      (countryCode) => CountryCodeToCountryMap[countryCode].currencyCode
+    )
+    if (this.response.status === 'loading') {
+      if (this.fetchPromise) {
+        const result = await this.fetchPromise
+        return result
+      }
+    }
+    this.response = {
+      status: 'loading',
+    }
+    this.fetchPromise = fetchConversionRate(BASE_URL, bCurrency, cCodes)
+    const result = await this.fetchPromise
+    this.response = result
+    this.fetchPromise = undefined
+    return this.response
+  }
+}
+
+function getCurrencySettings(
+  appConfig: AppConfig
+): AppConfig['integrations']['appbrew-currency'] {
+  if (!appConfig) return
+  return (
+    appConfig.settings?.['integrations']?.['appbrew-currency'] ??
+    appConfig.settings?.['appbrew-currency']
+  )
+}
+async function fetchConversionRate(
+  baseUrl: string,
+  baseCurrencyCode: string,
+  currencyCodes: Array<string>
+) {
+  let url = `${BASE_URL}?baseCurrencyCode=${baseCurrencyCode}`
+
+  if (currencyCodes) {
+    url = url.concat(`&currencyCodes=${currencyCodes.join(',')}`)
+  }
+  try {
+    const res = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-integration-app-name': 'AppBrew',
+        'x-app-id': EnvConfig.APP_ID,
+      },
+    })
+    if (res.status >= 400) {
+      return {
+        status: 'error',
+        error: {
+          message: `Server error, Please try after some time`,
+          rootCause: 'API error',
+          code: `API_ERROR_${res.status}`,
+        },
+      }
+    }
+    const result = await res.json()
+    return {
+      status: 'idle',
+      data: result,
+    }
+  } catch (e: any) {
+    return {
+      status: 'error',
+      error: {
+        message: 'fetch faile with exception',
+        rootCause: e.message,
+        code: `NETWORK_ERROR`,
+      },
+    }
+  }
+}

package/estimated-delivery-date/blocks/estimated-delivery-date.tsx

@@ -0,0 +1,229 @@
+import { Column, Row } from '@gauntlet/components/atoms/flex'
+import {
+  useBlockSettings,
+  useBlockStyle,
+} from '@gauntlet/components/style-utils'
+import { useBlock, useEdd } from '@gauntlet/state'
+import { BaseBlockProps } from '@gauntlet/types'
+import { Text } from '@gauntlet/components/atoms/text'
+import React from 'react'
+import { Input } from '@gauntlet/components/atoms/input'
+import { Button } from '@gauntlet/ui-builder'
+import { Keyboard } from 'react-native'
+import { add, format } from 'date-fns'
+
+export type AppbrewEstimatedDeliveryDateProps = BaseBlockProps
+
+export function AppbrewEstimatedDeliveryDate({
+  componentId,
+  instanceId,
+  screenId,
+}: AppbrewEstimatedDeliveryDateProps) {
+  const block = useBlock<any>(screenId, componentId, instanceId)
+  const style = useBlockStyle(block)
+  const { source, options } = useBlockSettings(block)
+  const pincodeRef = React.useRef<string>('')
+
+  const [pincode, setPincode] = React.useState('')
+
+  const [loading, setLoading] = React.useState(false)
+
+  const defaultEdd = {
+    codAvailable: null,
+    serviceable: null,
+    pincodeValidity: true,
+    minDeliveryDate: '',
+    maxDeliveryDate: '',
+    express: false,
+    pincodeRequired: false,
+  }
+
+  const [
+    {
+      codAvailable,
+      pincodeValidity,
+      serviceable,
+      minDeliveryDate,
+      maxDeliveryDate,
+      pincodeRequired,
+    },
+    setEddRes,
+  ] = React.useState<{
+    codAvailable: boolean | null
+    serviceable: boolean | null
+    pincodeValidity: boolean
+    minDeliveryDate: string
+    maxDeliveryDate: string
+    express: boolean
+    pincodeRequired: boolean
+  }>({
+    ...defaultEdd,
+  })
+  const { fetchEstimatedDeliveryDate } = useEdd()
+
+  const handleSubmit = React.useCallback(() => {
+    Keyboard.dismiss()
+
+    if (!pincodeRef?.current) {
+      setEddRes((res) => ({
+        ...res,
+        pincodeRequired: true,
+      }))
+      return
+    }
+
+    if (
+      (pincodeRef?.current?.length !== options?.pincodeLength ?? 6) ||
+      /^-?\d+$/.test(pincodeRef?.current) === false
+    ) {
+      setEddRes((res) => ({
+        ...res,
+        pincodeValidity: false,
+        serviceable: true,
+        codAvailable: true,
+      }))
+      return
+    }
+
+    setLoading(true)
+
+    return fetchEstimatedDeliveryDate(pincodeRef?.current)
+      .then((res) => {
+        if (res.isServiceable === false) {
+          setEddRes((res) => ({
+            ...res,
+            pincodeValidity: true,
+            serviceable: false,
+          }))
+          return
+        }
+
+        const cutoffDate = new Date(res.defaultCutoffTime * 1000)
+        const cutoffHours = cutoffDate.getUTCHours()
+        const cutoffMinutes = cutoffDate.getUTCMinutes()
+
+        // Get the current time
+        const currentDate = new Date()
+        const currentHours = currentDate.getUTCHours()
+        const currentMinutes = currentDate.getUTCMinutes()
+
+        // Compare the time components
+        let hasCutoffTimePassed = false
+        if (currentHours > cutoffHours) {
+          hasCutoffTimePassed = true
+        } else if (currentHours === cutoffHours) {
+          if (currentMinutes > cutoffMinutes) {
+            hasCutoffTimePassed = true
+          }
+        }
+
+        const minDate = format(
+          add(new Date(), {
+            days: Number(res.maxSLAInDays) + (hasCutoffTimePassed ? 1 : 0),
+          }),
+          'EEEE, LLL d'
+        )
+
+        const maxDate = format(
+          add(new Date(), {
+            days: Number(res.maxSLAInDays) + (hasCutoffTimePassed ? 1 : 0),
+          }),
+          'EEEE, LLL d'
+        )
+
+        const serviceable = res.isServiceable.toLowerCase() === 'true' ?? true
+        const codAvailable = res.isCODAvailable.toLowerCase() === 'true'
+
+        const pincodeValidity = true
+        const eddRes = {
+          minDeliveryDate: minDate,
+          maxDeliveryDate: maxDate,
+          codAvailable,
+          serviceable,
+          pincodeValidity,
+          express: Boolean(res.hyperlocal),
+        }
+        setEddRes(eddRes)
+      })
+      .catch((err) => {
+        console.error({ err })
+      })
+      .finally(() => {
+        setLoading(false)
+      })
+  }, [
+    fetchEstimatedDeliveryDate,
+    options?.additionalDays,
+    options?.pincodeLength,
+  ])
+
+  return (
+    <Column style={style?.container}>
+      <Text style={style?.title}>{source?.title}</Text>
+      <Row style={{ marginTop: 16, ...style?.inputContainer }}>
+        <Input
+          placeholder={source?.inputPlaceholder}
+          placeholderTextColor={style?.inputPlaceholderColor}
+          onChangeText={(text) => {
+            pincodeRef.current = text
+            setPincode(text)
+            setEddRes(defaultEdd)
+          }}
+          style={{
+            borderColor: pincodeValidity ? 'black' : 'red',
+            borderWidth: 1,
+            ...style?.input,
+          }}
+          keyboardType={'numeric'}
+          onSubmitEditing={handleSubmit}
+        />
+
+        <Button
+          onPress={handleSubmit}
+          text={source?.buttonText}
+          style={{
+            root: style.button.root,
+            text: style.button.text,
+            ...style.button,
+          }}
+          // disabled={pincode?.length <= 0}
+          loading={loading}
+        />
+      </Row>
+      {Boolean(
+        serviceable !== false &&
+          pincodeValidity &&
+          (minDeliveryDate || maxDeliveryDate)
+      ) && (
+        <Text style={style?.deliveryDateText}>
+          {Boolean(source?.template) && (
+            <Text style={style?.template}>{source?.template}</Text>
+          )}
+          {minDeliveryDate === maxDeliveryDate
+            ? `Expected delivery by ${minDeliveryDate}`
+            : `Expected delivery between ${minDeliveryDate} and ${maxDeliveryDate}`}
+        </Text>
+      )}
+
+      {Boolean(codAvailable && serviceable !== false && pincodeValidity) && (
+        <Text style={style?.codAvailableText}>{source?.codAvailableText}</Text>
+      )}
+
+      {Boolean(serviceable === false) && (
+        <Text style={style?.notServiceableText}>
+          {source?.notServiceableText}
+        </Text>
+      )}
+
+      {Boolean(!pincodeValidity) && (
+        <Text style={style?.invalidPincodeText}>
+          {source?.invalidPincodeText}
+        </Text>
+      )}
+
+      {Boolean(pincodeRequired) && (
+        <Text style={style?.pincodeRequired}>{source?.pincodeRequired}</Text>
+      )}
+    </Column>
+  )
+}

package/estimated-delivery-date/index.ts

@@ -0,0 +1,2 @@
+export * from './provider'
+export * from './blocks/estimated-delivery-date'

package/estimated-delivery-date/provider.ts

@@ -0,0 +1,45 @@
+import { EstimatedDeliveryDateProvider } from '@gauntlet/types'
+import EnvConfig from 'react-native-config'
+
+export class AppbrewEstimatedDeliveryDateProvider
+  implements EstimatedDeliveryDateProvider
+{
+  BASE_URL
+  private responseCache = new Map<string, any>()
+  static instance: AppbrewEstimatedDeliveryDateProvider
+
+  static getInstance() {
+    if (!AppbrewEstimatedDeliveryDateProvider.instance) {
+      AppbrewEstimatedDeliveryDateProvider.instance =
+        new AppbrewEstimatedDeliveryDateProvider()
+    }
+    return AppbrewEstimatedDeliveryDateProvider.instance
+  }
+  constructor() {
+    this.BASE_URL = `${EnvConfig['APP_SERVICE_URL']}/integrations/appbrew-edd/estimated-delivery-details`
+  }
+
+  estimateDeliveryDate = async (dropPincode: string, appId: string) => {
+    if (this.responseCache.has(dropPincode)) {
+      return this.responseCache.get(dropPincode)
+    }
+
+    const res = await fetch(`${this.BASE_URL}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-app-id': appId,
+      },
+      body: JSON.stringify({
+        zipCode: dropPincode,
+      }),
+    })
+
+    const jsonRes = await res.json()
+
+    if (res.ok) {
+      this.responseCache.set(dropPincode, jsonRes)
+      return jsonRes
+    } else throw new Error('Could not fetch estimated delivery date')
+  }
+}

package/native-wishlist/src/index.ts

@@ -0,0 +1 @@
+export * from "./provider"

package/native-wishlist/src/provider.ts

@@ -0,0 +1,88 @@
+import { LocalStorage } from '@gauntlet/local-storage'
+import { WishlistItem, WishlistProvider } from '@gauntlet/types'
+
+export class LocalWishlistProvider implements WishlistProvider {
+  static instance: LocalWishlistProvider
+
+  static getInstance() {
+    if (LocalWishlistProvider.instance) {
+      return LocalWishlistProvider.instance
+    }
+    LocalWishlistProvider.instance = new LocalWishlistProvider()
+
+    return LocalWishlistProvider.instance
+  }
+
+  WISHLIST_NATIVE_APPBREW_KEY = {
+    wishlistItems: 'wishlist-items',
+  }
+
+  init() {
+    if (!this.isInitialised()) {
+      LocalStorage.getInstance().set(
+        this.WISHLIST_NATIVE_APPBREW_KEY.wishlistItems,
+        JSON.stringify([])
+      )
+    }
+    return Promise.resolve()
+  }
+
+  getWishlist() {
+    const wishlistItems = getStoredValue(
+      this.WISHLIST_NATIVE_APPBREW_KEY.wishlistItems
+    )
+    return Promise.resolve(wishlistItems)
+  }
+
+  addToWishlist(products: WishlistItem[]) {
+    const wishlistItemsJson = getStoredValue(
+      this.WISHLIST_NATIVE_APPBREW_KEY.wishlistItems
+    )
+    if (wishlistItemsJson) {
+      const wishlistItemsList = Array.from(
+        new Set([...wishlistItemsJson.concat(products)])
+      )
+      LocalStorage.getInstance().set(
+        this.WISHLIST_NATIVE_APPBREW_KEY.wishlistItems,
+        wishlistItemsList as any
+      )
+    }
+    return Promise.resolve()
+  }
+
+  removeFromWishlist(itemsToBeRemoved: WishlistItem[]) {
+    const itemsInWishlist = getStoredValue(
+      this.WISHLIST_NATIVE_APPBREW_KEY.wishlistItems
+    )
+    const updatedList: Array<WishlistItem> = []
+    if (Array.isArray(itemsInWishlist)) {
+      for (const item of itemsInWishlist) {
+        const itemToBeRemoved = itemsToBeRemoved.find(
+          (product) => product.productId === item.productId
+        )
+        if (!itemToBeRemoved) {
+          updatedList.push(item)
+        }
+      }
+
+      LocalStorage.getInstance().set(
+        this.WISHLIST_NATIVE_APPBREW_KEY.wishlistItems,
+        updatedList as any
+      )
+    }
+    return Promise.resolve()
+  }
+
+  isInitialised() {
+    const wishlist = getStoredValue(
+      this.WISHLIST_NATIVE_APPBREW_KEY.wishlistItems
+    )
+    return Array.isArray(wishlist)
+  }
+}
+
+function getStoredValue(key: string) {
+  return LocalStorage.getInstance().getJson(key) as
+    | Array<WishlistItem>
+    | undefined
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@app-brew/appbrew",
+  "version": "1.0.0",
+  "files": [
+    "analytics/",
+    "currency/",
+    "estimated-delivery-date/",
+    "native-wishlist/",
+    "src/",
+    "tsconfig.paths.json"
+  ],
+  "peerDependencies": {
+    "@react-native-firebase/analytics": "23.3.1",
+    "@react-native-firebase/messaging": "23.3.1",
+    "@sentry/react-native": "7.8.0",
+    "date-fns": "2.30.0",
+    "react": "19.1.0",
+    "react-native": "0.81.0",
+    "react-native-base64": "^0.2.1",
+    "react-native-config": "1.5.9",
+    "@app-brew/brewery": ">=1.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './lib/integrations-appbrew'
+export * from '../native-wishlist/src'
+export * from '../analytics/tracker'
+export * from '../analytics/trackerV2'
+export * from '../analytics/webhook-tracker'
+export * from '../currency'
+export * from '../estimated-delivery-date'

package/src/lib/integrations-appbrew.spec.ts

@@ -0,0 +1,7 @@
+import { integrationsAppbrew } from './integrations-appbrew'
+
+describe('integrationsAppbrew', () => {
+  it('should work', () => {
+    expect(integrationsAppbrew()).toEqual('integrations-appbrew')
+  })
+})

package/src/lib/integrations-appbrew.ts

@@ -0,0 +1,3 @@
+export function integrationsAppbrew(): string {
+  return 'integrations-appbrew'
+}

package/tsconfig.paths.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@gauntlet/integrations/appbrew": [
+        "./src/index.ts"
+      ]
+    }
+  }
+}