@planningcenter/chat-react-native 3.20.1-rc.2 → 3.20.1-rc.3

package/src/hooks/use_conversation.ts

@@ -12,6 +12,7 @@ export const getConversationRequestArgs = ({ conversation_id }: { conversation_i
   data: {
     fields: {
       Conversation: [
+        'analytics_metadata',
         'created_at',
         'badges',
         'conversation_membership',
@@ -29,6 +30,7 @@ export const getConversationRequestArgs = ({ conversation_id }: { conversation_i
         'unread_count',
         'updated_at',
       ],
+      AnalyticsMetadata: ['metadata'],
       MemberAbility: [
         'can_update',
         'can_delete',
@@ -40,12 +42,20 @@ export const getConversationRequestArgs = ({ conversation_id }: { conversation_i
       ConversationBadge: ['app_name', 'pco_resource_type', 'text'],
       Group: ['type', 'id', 'links', 'name', 'source_app_name', 'source_type'],
     },
-    include: ['badges', 'conversation_membership', 'member_ability', 'groups'],
+    include: [
+      'badges',
+      'conversation_membership',
+      'member_ability',
+      'groups',
+      'analytics_metadata',
+    ],
   },
 })
 
 export const useConversation = ({ conversation_id }: { conversation_id: number }) => {
-  return useSuspenseGet<ConversationResource>(getConversationRequestArgs({ conversation_id }))
+  const args = getConversationRequestArgs({ conversation_id })
+
+  return useSuspenseGet<ConversationResource>(args)
 }
 
 export const useConversationMute = ({ conversation_id }: { conversation_id: number }) => {

package/src/hooks/use_product_analytics.ts

@@ -0,0 +1,107 @@
+import { useCallback, useEffect, useMemo, useRef } from 'react'
+import { SHA256, enc } from '../utils/sha_256'
+import { useChatContext } from '../contexts/chat_context'
+import { ProductAnalyticsConfig } from '../types/product_analytics'
+import { keysToSnakeCase } from '../utils/client/utils'
+import { AnalyticsMetadataResource } from '../types/resources/analytics_metadata'
+
+export interface EventMetadata {
+  [key: string]: string | number | boolean | null | undefined
+}
+
+interface AnalyticsEvent {
+  name: string
+  meta: EventMetadata
+}
+
+function contentSha256(payload: string): string {
+  return SHA256(payload).toString(enc.Hex)
+}
+
+function sendEvents(events: AnalyticsEvent[], config: ProductAnalyticsConfig): Promise<Response[]> {
+  // Split into chunks of 10 and make parallel requests
+  const chunks: AnalyticsEvent[][] = []
+  for (let i = 0; i < events.length; i += 10) {
+    chunks.push(events.slice(i, i + 10))
+  }
+
+  return Promise.all(
+    chunks.map(async chunk => {
+      const payload = JSON.stringify({ events: chunk })
+      return fetch(config.endpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json; charset=utf-8',
+          'X-Authorization': `Bearer ${config.token}`,
+          'X-Amz-Content-Sha256': contentSha256(payload),
+        },
+        body: payload,
+      })
+    })
+  )
+}
+
+const useProductAnalytics = () => {
+  const { productAnalyticsConfig } = useChatContext()
+
+  const snakeCasedBaseMeta = useMemo(
+    () => keysToSnakeCase(productAnalyticsConfig?.metadata || {}),
+    [productAnalyticsConfig?.metadata]
+  )
+
+  const publishEvent = useCallback(
+    (name: string, meta: EventMetadata = {}): Promise<Response[]> => {
+      if (!productAnalyticsConfig) {
+        if (__DEV__) {
+          console.warn('Product Analytics not available')
+        }
+        return Promise.resolve([])
+      }
+
+      const mergedMeta = { ...snakeCasedBaseMeta, ...meta } as EventMetadata
+
+      return sendEvents([{ name, meta: mergedMeta }], productAnalyticsConfig)
+    },
+    [productAnalyticsConfig, snakeCasedBaseMeta]
+  )
+
+  const publishEvents = useCallback(
+    (events: Array<{ name: string; meta?: EventMetadata }>): Promise<Response[]> => {
+      if (!productAnalyticsConfig) {
+        if (__DEV__) {
+          console.warn('Product Analytics not available')
+        }
+        return Promise.resolve([])
+      }
+
+      const eventsWithMeta = events.map(event => ({
+        name: event.name,
+        meta: { ...snakeCasedBaseMeta, ...event.meta } as EventMetadata,
+      }))
+
+      return sendEvents(eventsWithMeta, productAnalyticsConfig)
+    },
+    [productAnalyticsConfig, snakeCasedBaseMeta]
+  )
+
+  return { publishEvent, publishEvents }
+}
+
+export function usePublishProductAnalyticsEvent(eventName: string, meta: EventMetadata = {}) {
+  const { publishEvent } = useProductAnalytics()
+  const hasPublishedEventRef = useRef(false)
+
+  useEffect(() => {
+    if (hasPublishedEventRef.current) return
+
+    hasPublishedEventRef.current = true
+
+    publishEvent(eventName, meta)
+  }, [eventName, meta, publishEvent])
+}
+
+export function normalizeAnalyticsMetadata(resource: {
+  analyticsMetadata?: AnalyticsMetadataResource
+}) {
+  return keysToSnakeCase(resource?.analyticsMetadata?.metadata || {}) as Record<string, unknown>
+}

package/src/screens/conversation_screen.tsx

@@ -24,6 +24,10 @@ import { MessageForm } from '../components/conversation/message_form'
 import { TypingIndicator } from '../components/conversation/typing_indicator'
 import { KeyboardView } from '../components/display/keyboard_view'
 import { useTheme } from '../hooks'
+import {
+  normalizeAnalyticsMetadata,
+  usePublishProductAnalyticsEvent,
+} from '../hooks/use_product_analytics'
 import { useConversation } from '../hooks/use_conversation'
 import { useConversationMessages } from '../hooks/use_conversation_messages'
 import { useConversationMessagesJoltEvents } from '../hooks/use_conversation_messages_jolt_events'
@@ -56,6 +60,13 @@ export type ConversationScreenProps = StaticScreenProps<ConversationRouteProps>
 export function ConversationScreen({ route }: ConversationScreenProps) {
   const { conversation_id, reply_root_id } = route.params
 
+  const { data: conversation } = useConversation({ conversation_id })
+
+  usePublishProductAnalyticsEvent('chat.mobile.conversations.show.opened', {
+    reply_root_id,
+    ...normalizeAnalyticsMetadata(conversation),
+  })
+
   return (
     <ConversationContextProvider
       conversationId={conversation_id}

package/src/screens/conversations/conversations_screen.tsx

@@ -4,7 +4,7 @@ import { StyleSheet, View } from 'react-native'
 import { Conversations, TextButton } from '../../components'
 import { ActionButton } from '../../components/display/action_button'
 import { ConversationsContextProvider } from '../../contexts/conversations_context'
-import { useCanCreateConversations } from '../../hooks'
+import { useCanCreateConversations, usePublishProductAnalyticsEvent } from '../../hooks'
 import { AppName } from '../../types/resources/app_name'
 import { GraphId } from '../../types/resources/group_resource'
 import { destructureChatGroupGraphId, MAX_FONT_SIZE_MULTIPLIER_LANDMARK } from '../../utils'
@@ -60,6 +60,8 @@ export function ConversationsScreen({ route }: ConversationsScreenProps) {
     navigation.navigate('GetHelp', { type: 'chat' })
   }, [navigation])
 
+  usePublishProductAnalyticsEvent('chat.mobile.conversations.index.opened')
+
   return (
     <View style={styles.container}>
       <ConversationsContextProvider args={route.params}>

package/src/types/product_analytics.ts

@@ -0,0 +1,5 @@
+export interface ProductAnalyticsConfig {
+  token: string
+  endpoint: string
+  metadata: Record<string, unknown>
+}

package/src/types/resources/analytics_metadata.ts

@@ -0,0 +1,4 @@
+export interface AnalyticsMetadataResource {
+  id: number
+  metadata: Record<string, unknown>
+}

package/src/types/resources/conversation.ts

@@ -1,3 +1,4 @@
+import type { AnalyticsMetadataResource } from './analytics_metadata'
 import { ConversationBadgeResource } from './conversation_badge'
 import { GroupResource } from './group_resource'
 import { MemberAbilityResource } from './member_ability'
@@ -6,6 +7,7 @@ export interface ConversationResource {
   type: 'Conversation'
   id: number
   badges?: ConversationBadgeResource[]
+  analyticsMetadata?: AnalyticsMetadataResource
   conversationMembership?: {
     lastReadMessageSortKey: string
   }

package/src/types/resources/index.ts

@@ -1,3 +1,4 @@
+export * from './analytics_metadata'
 export * from './conversation'
 export * from './member'
 export * from './message'

package/src/utils/__tests__/sha_256.test.ts

@@ -0,0 +1,70 @@
+import { SHA256, enc } from '../sha_256'
+
+describe('SHA256', () => {
+  it('computes correct hash for empty string', () => {
+    const hash = SHA256('').toString(enc.Hex)
+    expect(hash).toBe('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855')
+  })
+
+  it('computes correct hash for "abc"', () => {
+    const hash = SHA256('abc').toString(enc.Hex)
+    expect(hash).toBe('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad')
+  })
+
+  it('computes correct hash for "The quick brown fox jumps over the lazy dog"', () => {
+    const hash = SHA256('The quick brown fox jumps over the lazy dog').toString(enc.Hex)
+    expect(hash).toBe('d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592')
+  })
+
+  it('computes correct hash for longer message', () => {
+    const message = 'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'
+    const hash = SHA256(message).toString(enc.Hex)
+    expect(hash).toBe('248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1')
+  })
+
+  it('computes correct hash for message with 1 million "a" characters', () => {
+    const message = 'a'.repeat(1000000)
+    const hash = SHA256(message).toString(enc.Hex)
+    expect(hash).toBe('cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0')
+  })
+
+  it('computes correct hash for UTF-8 string with emoji', () => {
+    const hash = SHA256('Hello 👋 World 🌍').toString(enc.Hex)
+    // This is the expected SHA-256 hash for this UTF-8 encoded string
+    expect(hash).toBe('c15ee319b97bfd23fa98590baf0b47d1f7b7b81f9e5bf99d8275867e2e4a32a2')
+  })
+
+  it('computes correct hash for JSON payload', () => {
+    const payload = JSON.stringify({ events: [{ name: 'test', meta: { foo: 'bar' } }] })
+    const hash = SHA256(payload).toString(enc.Hex)
+    expect(hash).toBe('5e4043aadad336890b9795ee03675a9de1a6abbc4e84f9f95daaffb21569312e')
+  })
+
+  it('toString without encoding parameter defaults to hex', () => {
+    const hash = SHA256('abc').toString()
+    expect(hash).toBe('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad')
+  })
+
+  it('produces consistent results for the same input', () => {
+    const input = 'test message'
+    const hash1 = SHA256(input).toString(enc.Hex)
+    const hash2 = SHA256(input).toString(enc.Hex)
+    expect(hash1).toBe(hash2)
+  })
+
+  it('produces different hashes for different inputs', () => {
+    const hash1 = SHA256('message 1').toString(enc.Hex)
+    const hash2 = SHA256('message 2').toString(enc.Hex)
+    expect(hash1).not.toBe(hash2)
+  })
+
+  it('handles strings with special characters', () => {
+    const hash = SHA256('!@#$%^&*()_+-=[]{}|;:",.<>?/~`').toString(enc.Hex)
+    expect(hash).toBe('67764597efaadfd3a9d89032105c9fcde16c6f05d16214e42488af193abb280a')
+  })
+
+  it('handles strings with newlines and tabs', () => {
+    const hash = SHA256('line1\nline2\tline3').toString(enc.Hex)
+    expect(hash).toBe('450c0302bb6c2b9d81f81c8c868f7e96e3a35bc83751a08b7da09e77c4f13eec')
+  })
+})

package/src/utils/request/conversation.ts

@@ -44,9 +44,10 @@ export const getConversationsRequestArgs = ({
           'unread_count',
           'updated_at',
         ],
+        AnalyticsMetadata: ['metadata'],
         ConversationBadge: ['app_name', 'pco_resource_type', 'text'],
       },
-      include: ['badges'],
+      include: ['badges', 'analytics_metadata'],
     },
   }
 }

package/src/utils/sha_256.ts

@@ -0,0 +1,229 @@
+/**
+ * Pure JavaScript SHA-256 implementation
+ * Conforms to the crypto-js API for drop-in replacement
+ */
+
+/* eslint-disable no-bitwise */
+
+// SHA-256 constants (first 32 bits of the fractional parts of the cube roots of the first 64 primes)
+const K = [
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]
+
+// Initial hash values (first 32 bits of the fractional parts of the square roots of the first 8 primes)
+const H = [
+  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]
+
+/** Right rotate 32-bit integer */
+function rotr(n: number, x: number): number {
+  return (x >>> n) | (x << (32 - n))
+}
+
+/** SHA-256 choice function */
+function ch(x: number, y: number, z: number): number {
+  return (x & y) ^ (~x & z)
+}
+
+/** SHA-256 majority function */
+function maj(x: number, y: number, z: number): number {
+  return (x & y) ^ (x & z) ^ (y & z)
+}
+
+/** SHA-256 Σ0 function */
+function sigma0(x: number): number {
+  return rotr(2, x) ^ rotr(13, x) ^ rotr(22, x)
+}
+
+/** SHA-256 Σ1 function */
+function sigma1(x: number): number {
+  return rotr(6, x) ^ rotr(11, x) ^ rotr(25, x)
+}
+
+/** SHA-256 σ0 function */
+function gamma0(x: number): number {
+  return rotr(7, x) ^ rotr(18, x) ^ (x >>> 3)
+}
+
+/** SHA-256 σ1 function */
+function gamma1(x: number): number {
+  return rotr(17, x) ^ rotr(19, x) ^ (x >>> 10)
+}
+
+/** Convert string to UTF-8 byte array */
+function stringToBytes(str: string): number[] {
+  const bytes: number[] = []
+  for (let i = 0; i < str.length; i++) {
+    let charCode = str.charCodeAt(i)
+    if (charCode < 0x80) {
+      bytes.push(charCode)
+    } else if (charCode < 0x800) {
+      bytes.push(0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f))
+    } else if (charCode < 0xd800 || charCode >= 0xe000) {
+      bytes.push(0xe0 | (charCode >> 12), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f))
+    } else {
+      // Surrogate pair
+      i++
+      charCode = 0x10000 + (((charCode & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff))
+      bytes.push(
+        0xf0 | (charCode >> 18),
+        0x80 | ((charCode >> 12) & 0x3f),
+        0x80 | ((charCode >> 6) & 0x3f),
+        0x80 | (charCode & 0x3f)
+      )
+    }
+  }
+  return bytes
+}
+
+/** Preprocess message: pad and convert to 512-bit blocks */
+function preprocessMessage(message: number[]): Uint32Array {
+  const messageLength = message.length
+  const bitLength = messageLength * 8
+
+  // Append the '1' bit (plus zero padding to make 8 bits)
+  message.push(0x80)
+
+  // Append zeros until message length ≡ 448 (mod 512)
+  // This leaves 64 bits for the length
+  while (message.length % 64 !== 56) {
+    message.push(0x00)
+  }
+
+  // Append original message length as 64-bit big-endian integer
+  // JavaScript numbers are 53-bit safe, so we split into two 32-bit parts
+  const lengthHigh = Math.floor(bitLength / 0x100000000)
+  const lengthLow = bitLength >>> 0
+
+  for (let i = 24; i >= 0; i -= 8) {
+    message.push((lengthHigh >>> i) & 0xff)
+  }
+  for (let i = 24; i >= 0; i -= 8) {
+    message.push((lengthLow >>> i) & 0xff)
+  }
+
+  // Convert byte array to 32-bit word array
+  const words = new Uint32Array(message.length / 4)
+  for (let i = 0; i < message.length; i += 4) {
+    words[i / 4] =
+      (message[i] << 24) | (message[i + 1] << 16) | (message[i + 2] << 8) | message[i + 3]
+  }
+
+  return words
+}
+
+/** Process a single 512-bit chunk */
+function processChunk(chunk: Uint32Array, hash: number[]): void {
+  const W = new Uint32Array(64)
+
+  // Prepare message schedule
+  for (let t = 0; t < 16; t++) {
+    W[t] = chunk[t]
+  }
+  for (let t = 16; t < 64; t++) {
+    W[t] = (gamma1(W[t - 2]) + W[t - 7] + gamma0(W[t - 15]) + W[t - 16]) >>> 0
+  }
+
+  // Initialize working variables
+  let a = hash[0]
+  let b = hash[1]
+  let c = hash[2]
+  let d = hash[3]
+  let e = hash[4]
+  let f = hash[5]
+  let g = hash[6]
+  let h = hash[7]
+
+  // Main loop
+  for (let t = 0; t < 64; t++) {
+    const T1 = (h + sigma1(e) + ch(e, f, g) + K[t] + W[t]) >>> 0
+    const T2 = (sigma0(a) + maj(a, b, c)) >>> 0
+    h = g
+    g = f
+    f = e
+    e = (d + T1) >>> 0
+    d = c
+    c = b
+    b = a
+    a = (T1 + T2) >>> 0
+  }
+
+  // Add compressed chunk to current hash value
+  hash[0] = (hash[0] + a) >>> 0
+  hash[1] = (hash[1] + b) >>> 0
+  hash[2] = (hash[2] + c) >>> 0
+  hash[3] = (hash[3] + d) >>> 0
+  hash[4] = (hash[4] + e) >>> 0
+  hash[5] = (hash[5] + f) >>> 0
+  hash[6] = (hash[6] + g) >>> 0
+  hash[7] = (hash[7] + h) >>> 0
+}
+
+/** Compute SHA-256 hash and return as byte array */
+function sha256Raw(message: string): number[] {
+  const bytes = stringToBytes(message)
+  const preprocessed = preprocessMessage(bytes)
+  const hash = [...H] // Copy initial hash values
+
+  // Process each 512-bit chunk
+  for (let i = 0; i < preprocessed.length; i += 16) {
+    const chunk = preprocessed.subarray(i, i + 16)
+    processChunk(chunk, hash)
+  }
+
+  // Convert hash to byte array
+  const result: number[] = []
+  for (let i = 0; i < 8; i++) {
+    result.push((hash[i] >>> 24) & 0xff)
+    result.push((hash[i] >>> 16) & 0xff)
+    result.push((hash[i] >>> 8) & 0xff)
+    result.push(hash[i] & 0xff)
+  }
+
+  return result
+}
+
+/** Hash result object with toString methods */
+class HashResult {
+  private bytes: number[]
+
+  constructor(bytes: number[]) {
+    this.bytes = bytes
+  }
+
+  /** Convert hash to hexadecimal string */
+  toString(encoding?: { stringify: (bytes: number[]) => string }): string {
+    if (encoding === Hex) {
+      return this.bytes.map(b => b.toString(16).padStart(2, '0')).join('')
+    }
+    // Default to hex if no encoding specified
+    return this.bytes.map(b => b.toString(16).padStart(2, '0')).join('')
+  }
+}
+
+/** Hex encoding object (mimics crypto-js enc.Hex) */
+export const Hex = {
+  stringify: (bytes: number[]) => bytes.map(b => b.toString(16).padStart(2, '0')).join(''),
+}
+
+/**
+ * Compute SHA-256 hash of a string
+ * @param message - The message to hash
+ * @returns HashResult object with toString method
+ */
+export function SHA256(message: string): HashResult {
+  const hash = sha256Raw(message)
+  return new HashResult(hash)
+}
+
+/** Encoding utilities (mimics crypto-js enc) */
+export const enc = {
+  Hex,
+}