Update hubspt custom event action to handle numeric strings

Author: harsh-joshi99

packages/destination-actions/src/destinations/hubspot/customEvent/__tests__/index.test.ts

@@ -815,4 +815,288 @@ describe('Hubspot.customEvent', () => {
       )
     })
   })
+
+  describe('numeric string handling', () => {
+    const numericStringPayload = {
+      timestamp: timestamp,
+      event: 'Custom Event 2',
+      messageId: 'aaa-bbb-ccc',
+      type: 'track',
+      userId: 'user_id_1',
+      properties: {
+        custom_prop_str: 'Hello String!',
+        custom_prop_numeric_string: '123' // will be inferred as number but should be string
+      }
+    } as Partial<SegmentEvent>
+
+    const expectedNumericStringPayload = {
+      eventName: 'pe23132826_custom_event_2',
+      objectId: undefined,
+      email: '[email protected]',
+      utk: undefined,
+      occurredAt: timestamp,
+      properties: {
+        custom_prop_str: 'Hello String!',
+        custom_prop_numeric_string: '123' // converted to string
+      }
+    }
+
+    const multipleNumericStringsPayload = {
+      timestamp: timestamp,
+      event: 'Custom Event 3',
+      messageId: 'aaa-bbb-ccc',
+      type: 'track',
+      userId: 'user_id_1',
+      properties: {
+        prop1: 123,
+        prop2: 456.78,
+        prop3: 0,
+        prop4: 'regular string'
+      }
+    } as Partial<SegmentEvent>
+
+    const expectedMultipleNumericStringsPayload = {
+      eventName: 'pe23132826_custom_event_3',
+      objectId: undefined,
+      email: '[email protected]',
+      utk: undefined,
+      occurredAt: timestamp,
+      properties: {
+        prop1: '123',
+        prop2: '456.78',
+        prop3: '0',
+        prop4: 'regular string'
+      }
+    }
+
+    const numericTypePayload = {
+      timestamp: timestamp,
+      event: 'Custom Event 6',
+      messageId: 'aaa-bbb-ccc',
+      type: 'track',
+      userId: 'user_id_1',
+      properties: {
+        numeric_prop: 123,
+        string_prop: 'test'
+      }
+    } as Partial<SegmentEvent>
+
+    const expectedNumericTypePayload = {
+      eventName: 'pe23132826_custom_event_6',
+      objectId: undefined,
+      email: '[email protected]',
+      utk: undefined,
+      occurredAt: timestamp,
+      properties: {
+        numeric_prop: 123, // should stay as number
+        string_prop: 'test'
+      }
+    }
+
+    it('should convert numeric string from cache and send event without hitting HubSpot', async () => {
+      const event = createTestEvent(numericStringPayload)
+
+      // fetches the event definition from Hubspot
+      nock('https://api.hubapi.com')
+        .get('/events/v3/event-definitions/custom_event_2/?includeProperties=true')
+        .reply(200, {
+          name: 'custom_event_2',
+          fullyQualifiedName: 'pe23132826_custom_event_2',
+          properties: [
+            {
+              name: 'custom_prop_str',
+              type: 'string',
+              archived: false
+            },
+            {
+              name: 'custom_prop_numeric_string',
+              type: 'string', // HubSpot has this as string, not number
+              archived: false
+            }
+          ]
+        })
+
+      // sends an event completion to Hubspot
+      nock('https://api.hubapi.com').post('/events/v3/send', expectedNumericStringPayload).reply(200, {})
+
+      const responses = await testDestination.testAction('customEvent', {
+        event,
+        settings,
+        useDefaultMappings: true,
+        mapping: upsertMapping,
+        subscriptionMetadata
+      })
+
+      expect(responses.length).toBe(2)
+      expect(responses[1].status).toBe(200)
+
+      // sends an event completion to Hubspot without first fetching the event definition
+      nock('https://api.hubapi.com').post('/events/v3/send', expectedNumericStringPayload).reply(200, {})
+
+      const responses2 = await testDestination.testAction('customEvent', {
+        event: createTestEvent(numericStringPayload),
+        settings,
+        useDefaultMappings: true,
+        mapping: upsertMapping,
+        subscriptionMetadata
+      })
+
+      expect(responses2.length).toBe(1)
+      expect(responses2[0].status).toBe(200)
+    })
+
+    it('should handle multiple numeric strings in a single event', async () => {
+      const event = createTestEvent(multipleNumericStringsPayload)
+
+      // fetches the event definition from Hubspot
+      nock('https://api.hubapi.com')
+        .get('/events/v3/event-definitions/custom_event_3/?includeProperties=true')
+        .reply(200, {
+          name: 'custom_event_3',
+          fullyQualifiedName: 'pe23132826_custom_event_3',
+          properties: [
+            {
+              name: 'prop1',
+              type: 'string',
+              archived: false
+            },
+            {
+              name: 'prop2',
+              type: 'string',
+              archived: false
+            },
+            {
+              name: 'prop3',
+              type: 'string',
+              archived: false
+            },
+            {
+              name: 'prop4',
+              type: 'string',
+              archived: false
+            }
+          ]
+        })
+
+      // sends an event completion to Hubspot
+      nock('https://api.hubapi.com').post('/events/v3/send', expectedMultipleNumericStringsPayload).reply(200, {})
+
+      const responses = await testDestination.testAction('customEvent', {
+        event,
+        settings,
+        useDefaultMappings: true,
+        mapping: upsertMapping,
+        subscriptionMetadata
+      })
+
+      expect(responses.length).toBe(2)
+      expect(responses[1].status).toBe(200)
+    })
+
+    it('should handle numeric strings with partial property match', async () => {
+      const event = createTestEvent({
+        timestamp: timestamp,
+        event: 'Custom Event 5',
+        messageId: 'aaa-bbb-ccc',
+        type: 'track',
+        userId: 'user_id_1',
+        properties: {
+          existing_prop: 123,
+          new_prop: 'new value'
+        }
+      } as Partial<SegmentEvent>)
+
+      // fetches the event definition from Hubspot
+      nock('https://api.hubapi.com')
+        .get('/events/v3/event-definitions/custom_event_5/?includeProperties=true')
+        .reply(200, {
+          name: 'custom_event_5',
+          fullyQualifiedName: 'pe23132826_custom_event_5',
+          properties: [
+            {
+              name: 'existing_prop',
+              type: 'string', // numeric string
+              archived: false
+            }
+            // new_prop doesn't exist yet
+          ]
+        })
+
+      const expectedHubspotCreatePropertyPayload = {
+        name: 'new_prop',
+        label: 'new_prop',
+        type: 'string',
+        description: 'new_prop - (created by Segment)'
+      }
+
+      // creates property on Hubspot
+      nock('https://api.hubapi.com')
+        .post('/events/v3/event-definitions/pe23132826_custom_event_5/property', expectedHubspotCreatePropertyPayload)
+        .reply(200, {})
+
+      // sends an event completion to Hubspot
+      nock('https://api.hubapi.com')
+        .post('/events/v3/send', {
+          eventName: 'pe23132826_custom_event_5',
+          objectId: undefined,
+          email: '[email protected]',
+          utk: undefined,
+          occurredAt: timestamp,
+          properties: {
+            existing_prop: '123',
+            new_prop: 'new value'
+          }
+        })
+        .reply(200, {})
+
+      const responses = await testDestination.testAction('customEvent', {
+        event,
+        settings,
+        useDefaultMappings: true,
+        mapping: upsertMapping,
+        subscriptionMetadata
+      })
+
+      expect(responses.length).toBe(3)
+      expect(responses[2].status).toBe(200)
+    })
+
+    it('should not convert numeric values when HubSpot schema expects number type', async () => {
+      const event = createTestEvent(numericTypePayload)
+
+      // fetches the event definition from Hubspot
+      nock('https://api.hubapi.com')
+        .get('/events/v3/event-definitions/custom_event_6/?includeProperties=true')
+        .reply(200, {
+          name: 'custom_event_6',
+          fullyQualifiedName: 'pe23132826_custom_event_6',
+          properties: [
+            {
+              name: 'numeric_prop',
+              type: 'number', // HubSpot expects number, not string
+              archived: false
+            },
+            {
+              name: 'string_prop',
+              type: 'string',
+              archived: false
+            }
+          ]
+        })
+
+      // sends an event completion to Hubspot
+      nock('https://api.hubapi.com').post('/events/v3/send', expectedNumericTypePayload).reply(200, {})
+
+      const responses = await testDestination.testAction('customEvent', {
+        event,
+        settings,
+        useDefaultMappings: true,
+        mapping: upsertMapping,
+        subscriptionMetadata
+      })
+
+      expect(responses.length).toBe(2)
+      expect(responses[1].status).toBe(200)
+    })
+  })
 })

packages/destination-actions/src/destinations/hubspot/customEvent/functions/cache-functions.ts

@@ -2,6 +2,7 @@ import { PayloadValidationError, StatsContext } from '@segment/actions-core'
 import { SubscriptionMetadata } from '@segment/actions-core/destination-kit'
 import { SegmentProperty, Schema, CachableSchema, SchemaDiff } from '../types'
 import { LRUCache } from 'lru-cache'
+import { Payload } from '../generated-types'
 
 export const cache = new LRUCache<string, CachableSchema>({
   max: 2000,
@@ -42,21 +43,27 @@ export async function saveSchemaToCache(
 
 export function compareSchemas(schema1: Schema, schema2: CachableSchema | undefined): SchemaDiff {
   if (schema2 === undefined) {
-    return { match: 'no_match', missingProperties: {} }
+    return { match: 'no_match', missingProperties: {}, numericStrings: [] }
   }
 
   if (schema1.name !== schema2.name && schema1.name !== schema2.fullyQualifiedName) {
     throw new PayloadValidationError("Hubspot.CustomEvent.compareSchemas: Schema names don't match")
   }
 
   const missingProperties: { [key: string]: SegmentProperty } = {}
+  const numericStrings: string[] = []
 
   for (const [key, prop1] of Object.entries(schema1.properties)) {
     const prop2 = schema2.properties[key]
     if (prop2 === undefined) {
       missingProperties[key] = prop1
       continue
     }
+    // Handle case where we inferred number but HubSpot/cache has string
+    if (prop1.type === 'number' && prop2.type === 'string') {
+      numericStrings.push(key)
+      continue
+    }
     if (prop1.stringFormat === prop2.stringFormat && prop1.type === prop2.type) {
       continue
     } else {
@@ -66,6 +73,23 @@ export function compareSchemas(schema1: Schema, schema2: CachableSchema | undefi
 
   return {
     match: Object.keys(missingProperties).length > 0 ? 'properties_missing' : 'full_match',
-    missingProperties
+    missingProperties,
+    numericStrings
+  }
+}
+
+/**
+ * Converts numeric property values to strings when the schema indicates they should be strings.
+ * This handles the case where numeric strings like "123" get coerced to numbers during schema inference,
+ * but HubSpot actually has the property defined as a string type.
+ */
+export function convertNumericStrings(validPayload: Payload, numericStrings: string[]): void {
+  if (!validPayload.properties || numericStrings.length === 0) {
+    return
+  }
+  for (const propName of numericStrings) {
+    if (validPayload.properties[propName] !== undefined) {
+      validPayload.properties[propName] = String(validPayload.properties[propName])
+    }
   }
 }

packages/destination-actions/src/destinations/hubspot/customEvent/functions/hubspot-event-schema-functions.ts

@@ -11,8 +11,13 @@ import {
   PropertyCreateResp
 } from '../types'
 import { Client } from '../client'
+import { Payload } from '../generated-types'
 
-export async function getSchemaFromHubspot(client: Client, schema: Schema): Promise<CachableSchema | undefined> {
+export async function getSchemaFromHubspot(
+  client: Client,
+  schema: Schema,
+  validPayload: Payload
+): Promise<CachableSchema | undefined> {
   const response = await client.getEventDefinition(schema.name)
 
   switch (response.status) {
@@ -50,13 +55,26 @@ export async function getSchemaFromHubspot(client: Client, schema: Schema): Prom
               )
             }
 
-            if (prop.type === 'number' && ['datetime', 'string', 'enumeration'].includes(maybeMatch.type)) {
+            // If we inferred type as number but HubSpot has string, convert back to string
+            if (prop.type === 'number' && maybeMatch.type === 'string') {
+              // Convert the payload property value to string
+              if (validPayload.properties && validPayload.properties[propName] !== undefined) {
+                validPayload.properties[propName] = String(validPayload.properties[propName])
+              }
+              // Update schema to match HubSpot's type
+              props[propName] = {
+                type: 'string',
+                stringFormat: 'string'
+              }
+            }
+            // For other type mismatches with number, still throw error
+            else if (prop.type === 'number' && ['datetime', 'enumeration'].includes(maybeMatch.type)) {
               throw new PayloadValidationError(
                 `Hubspot.CustomEvent.getSchemaFromHubspot: Expected type ${prop.type} for property ${propName} - Hubspot returned type ${maybeMatch.type}`
               )
+            } else {
+              props[propName] = schema.properties[propName]
             }
-
-            props[propName] = schema.properties[propName]
           }
           return props
         })()