@ht-sdks/events-sdk-js-browser 1.0.4 → 1.2.0

package/src/core/http-cookies/README.md

@@ -0,0 +1,194 @@
+# HTTPOnly Cookies
+
+## "Browser Cookies" vs "Server Cookies"
+
+**Cookies are serialized sets of key-value pairs that the browser can send to the server when making an HTTP request (e.g. on the `Cookie` header)**. Traditionally, the browser does this to identify itself when calling the server. For example, it might receive a cookie when calling a `/login` route, and then continue to send this cookie on subsequent requests, proving that the user is still logged-in. Alternatively, browsers can use cookies just for storing local data, like localStorage.
+
+Normally, **both** the client and the server can CRUD cookies.
+
+However, as a security measure, browsers restrict Javascript access to cookies containing the `HTTPOnly` property. These cookies are **only** intended to be created and read by the server.
+
+## "Browser Cookies" for event attribution
+
+Certain browsers (e.g. Safari) limit "Browser Cookies" to a 7 day expiry.
+
+A user visiting a website on both 01/01/2023 and 01/14/2023 will look like two different users. The browser will delete the user's "anonymousId cookie" before the user begins their second session on 01/14/2023.
+
+## "Server Cookies" for event attribution
+
+These expiry limits don't have to apply to "Server Cookies".
+
+A user visiting a website on both 01/01/2023 and 01/14/2023 can still look like the same user, provided that there is a way to "regenerate" the user's same "anonymousId cookie" from the earlier session. To do this, the following must happen:
+1. User begins their session on 01/01/2023
+1. Events SDK creates an anonymousId "browser cookie"
+1. Events SDK sends "browser cookie" to `$server` and receives back an HTTPOnly cookie with the same anonymousId
+1. HTTPOnly cookie remains on the user's device
+1. User begins their second session on 01/14/2023
+1. Events SDK sends the HTTPOnly cookie to `$server` and receives back a "browser cookie" with the same anonymousId as the first session
+
+**The `$server` must be the same server that serves your website.** Certain browsers (e.g. Safari) will still enforce a 7 day expiry--even for "server cookies"--unless the following criteria are met:
+1. The `$server` providing the HTTPOnly cookie must be on the same domain as the website.
+1. If `$server` is on a subdomain of the website, its IP address must match the IP address that served the main HTML document.
+
+Routing a subdomain via DNS will not suffice. You'll need **one of** the following:
+- A **webserver** that serves  both your HTML document and an API (e.g. something like Django, Rails, Spring, etc)
+- A **reverse proxy** that can forward requests for your HTML document to one place, your API requests to another, and make it look like it's all on one server (e.g. NGINX, Caddy, etc)
+- A **CDN** that can run programmatic logic when matching certain requests (e.g. Lambda@Edge, Clouflare Workers, etc)
+
+## Client SDK Setup
+
+```javascript
+import { HtEventsBrowser } from '@ht-sdks/events-sdk-js-browser'
+
+const htevents = HtEventsBrowser.load(
+  { writeKey: '<YOUR_WRITE_KEY>'},
+  { 
+    apiHost: "us-east-1.hightouch-events.com", // HtEvents API remains the same
+    httpCookieServiceOptions: {
+      clearUrl: 'ht/clear', // route hosted on *your* domain and infra
+      renewUrl: 'ht/renew', // route hosted on *your* domain and infra
+    }
+  },
+)
+
+htevents.identify('hello world')
+
+document.body?.addEventListener('click', () => {
+  htevents.track('document body clicked!')
+})
+```
+
+## Server Setup
+
+The Events SDK expects to interact with a customer's `$server` that implements a specific spec for two routes. You can name the endpoints whatever you want.
+
+### An API for **creating** server and browser cookies
+
+This route should look for the following **browser** cookies (from Events SDK):
+* `request.headers.get('Cookie')["htjs_anonymous_id"]`
+* `request.headers.get('Cookie')["htjs_user_id"]`
+
+This route should return these values as **server** cookies:
+* `response.cookie("htjs_anonymous_id_srvr", anonVal, {httpOnly:true, ...})`
+* `response.cookie("htjs_user_id_srvr", userIdVal, {httpOnly:true, ...})`
+
+If there are no browser cookies found, return any server cookies as browser cookies:
+* `response.cookie("htjs_anonymous_id", anonVal, ...)`
+* `response.cookie("htjs_user_id", userIdVal, ...)`
+
+### An API for **clearing** server cookies
+
+This route should look for **server** cookies and clean them:
+* `res.cookie("htjs_anonymous_id_srvr", "", {maxAge: 0, httpOnly:true});`
+* `res.cookie("htjs_user_id_srvr", "", {maxAge: 0, httpOnly:true});`
+
+### API Spec
+The spec of the actual `request` and `response` payloads are kept intentionally vague. The spec should fit a variety of server environments.
+
+The Events SDK only requires that the server: A) handles cookies and B) returns a `200` statuscode.
+
+## Server Example
+
+A simplified Node.js/Express server:
+
+```Javascript
+const express = require("express");
+const cookieParser = require('cookie-parser');
+const cors = require('cors');
+
+const USER_COOKIE = "htjs_user_id";
+const ANON_COOKIE = "htjs_anonymous_id";
+
+function getDomain(req) {
+  let domain = process.env.DOMAIN || req.headers["x-forwarded-for"] || req.get("host");
+  if (domain.startsWith("localhost")) return "localhost";
+  return domain;
+}
+
+function renewCookies(req, res, browserName, serverName) {
+  const cookie = req.cookies[browserName] || req.cookies[serverName];
+  if (!cookie) return "";
+  const cookieParams = {maxAge:31536000*1000, domain: getDomain(req), sameSite: "lax"};
+  res.cookie(browserName, cookie, {...cookieParams});
+  res.cookie(serverName, cookie, {...cookieParams, httpOnly:true});
+  return cookie;
+}
+
+function clearServerCookie(req, res, serverName) {
+  const cookie = "";
+  const cookieParams = {maxAge:0, domain: getDomain(req), sameSite: "lax"};
+  res.cookie(serverName, "", {...cookieParams, httpOnly:true});
+  return cookie;
+}
+
+const app = express();
+app.use(cookieParser());
+app.use(cors())
+
+app.post("/ht/renew", (req, res) => {
+  // recreate a browser cookie from an existing server cookie, OR
+  // create a new server cookie that can later be used to recreate from.
+  return res.json({
+    userId: renewCookies(req, res, USER_COOKIE, `${USER_COOKIE}_srvr`),
+    anonymousId: renewCookies(req, res, ANON_COOKIE, `${ANON_COOKIE}_srvr`),
+  })
+});
+
+app.post("/ht/clear", (req, res) => {
+  // clear server cookies, e.g. if the user asks to clear all cookies.
+  return res.json({
+    userId: clearServerCookie(req, res, `${USER_COOKIE}_srvr`),
+    anonymousId: clearServerCookie(req, res, `${ANON_COOKIE}_srvr`),
+  })
+});
+
+app.listen(3000, () => {
+  console.log("Listening on port 3000...");
+});
+```
+
+A **very** simplified NGINX reverse proxy serving your document and API from the same domain:
+```
+worker_processes  1;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    default_type  application/octet-stream;
+    sendfile        on;
+    keepalive_timeout  65;
+
+    server {
+        listen       8080;
+        server_name  localhost;
+
+        location / {
+            root   /Users/name/src/website/html;
+            index  index.html index.htm;
+        }
+
+        location /cdn {
+            #autoindex on;
+            alias  /Users/name/src/website/cdn;
+            try_files $uri /index.html =404;
+        }
+
+        location /ht {
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header Host $host;
+            proxy_pass http://127.0.0.1:3000;
+        }
+
+    }
+
+    include servers/*;
+}
+```
+
+**These server examples should not be used as is.** They should be adapted to your setup and "productionized". The general concepts remain the same though.
+
+## More information
+- Safari: https://webkit.org/blog/9521/intelligent-tracking-prevention-2-3/
+

package/src/core/http-cookies/index.ts

@@ -0,0 +1,152 @@
+import { fetch } from '../../lib/fetch'
+
+type DeferredRequest = () => Promise<Response>
+
+export type HTTPCookieServiceOptions = {
+  renewUrl: string
+  clearUrl: string
+  retries?: number
+  backoff?: number
+  flushInterval?: number
+}
+
+/**
+ * `HTTPCookieService.load(...)` should be awaited inside `loadAnalytics(...)`.
+ * If the server can recreate an expired "Browser Cookie", by inspecting existing
+ * "Server Cookies", we should delay dispatching events until receiving the Cookie.
+ *
+ *  dispatch$Method class methods should be used after any cookie interactions:
+ * `dispatchCreate()` should be called after creating any new browser cookies.
+ * `dispatchClear()` should be called after clearing any browser cookies.
+ *
+ * Manual `startQueueConsumer()` or `stopQueueConsumer()` is not usually necessary.
+ *
+ * Glossary:
+ * "Server Cookies": `HTTPOnly:true`, stored on client, but only server can access.
+ * "Browser Cookies": `HTTPOnly:false`, stored on client, and both client and server can access.
+ */
+export class HTTPCookieService {
+  private queue: DeferredRequest[]
+  private renewUrl: string
+  private clearUrl: string
+  private retries: number
+  private backoff: number
+  private flushInterval: number
+  private flushIntervalId?: NodeJS.Timer
+
+  private constructor(options: HTTPCookieServiceOptions) {
+    this.renewUrl = options.renewUrl
+    this.clearUrl = options.clearUrl
+    this.backoff = options.backoff ?? 300
+    this.retries = options.retries ?? 3
+    this.flushInterval = options.flushInterval ?? 1000
+    this.queue = []
+  }
+
+  static async load(
+    options: HTTPCookieServiceOptions
+  ): Promise<HTTPCookieService> {
+    const cookieService = new HTTPCookieService(options)
+
+    // renew any existing HTTPCookies already on the device
+    // we want `load()` to block on this, so await directly instead of calling dispatch
+    const req = cookieService.sendHTTPCookies(options.renewUrl)
+    await retry(req, cookieService.retries, cookieService.backoff).catch(
+      console.error
+    )
+
+    // consume HTTPCookie actions, sequentially, as needed
+    cookieService.startQueueConsumer()
+
+    return cookieService
+  }
+
+  dispatchCreate() {
+    this.queue.push(this.sendHTTPCookies(this.renewUrl))
+  }
+
+  dispatchClear() {
+    this.queue.push(this.sendHTTPCookies(this.clearUrl))
+  }
+
+  startQueueConsumer() {
+    if (this.flushIntervalId) {
+      console.error('HTTPCookie queue consumer is already running.')
+      return
+    }
+    const bound = this.consumeQueue.bind(this)
+    this.flushIntervalId = setInterval(
+      () => bound().catch(console.error),
+      this.flushInterval
+    )
+  }
+
+  stopQueueConsumer() {
+    if (!this.flushIntervalId) {
+      console.error('HTTPCookie queue consumer is already stopped.')
+      return
+    }
+    clearInterval(this.flushIntervalId)
+    this.flushIntervalId = undefined
+  }
+
+  private sendHTTPCookies(serviceUrl: string): DeferredRequest {
+    return async function (): Promise<Response> {
+      return await fetch(serviceUrl, {
+        credentials: 'include',
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+        },
+        method: 'post',
+        body: JSON.stringify({
+          sentAt: new Date().toISOString(),
+        }),
+      })
+    }
+  }
+
+  /**
+   * This queue exists to avoid race conditions.
+   *
+   * Customer-developers may not `await` all promises.
+   *
+   * Therefore, introducing async code into analytics.track(), etc
+   * could create race conditions in customer code.
+   *
+   * The queue enforces: if someone calls analytics.clear()
+   * before calling analytics.identify(), the cookie service
+   * will consume those actions, sequentially, even if no promises
+   * are awaited.
+   */
+  private async consumeQueue() {
+    while (this.queue.length > 0) {
+      const req = this.queue.shift() as DeferredRequest
+      await retry(req, this.retries, this.backoff).catch(console.error)
+    }
+  }
+}
+
+async function sleep(delayMS: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, delayMS))
+}
+
+async function retry(
+  req: DeferredRequest,
+  retries: number,
+  backoff: number
+): Promise<Response> {
+  while (retries >= 0) {
+    try {
+      return await req().then((res) => {
+        if (res.ok) return res
+        throw new Error(`Status: ${res.status} ${res.statusText}`)
+      })
+    } catch (error) {
+      retries -= 1
+      if (retries <= 0) throw error
+      await sleep(backoff)
+    }
+  }
+  throw Error('HtEvents: Problem with DeferredRequest')
+}

package/src/core/page/add-page-context.ts

@@ -1,5 +1,5 @@
 import { pick } from '../../lib/pick'
-import { EventProperties, SegmentEvent } from '../events'
+import { EventProperties, HightouchEvent } from '../events'
 import { getDefaultPageContext } from './get-page-context'
 
 /**
@@ -9,7 +9,7 @@ import { getDefaultPageContext } from './get-page-context'
  * We prefer not to add this information to this function, as it increases the main bundle size.
  */
 export const addPageContext = (
-  event: SegmentEvent,
+  event: HightouchEvent,
   pageCtx = getDefaultPageContext()
 ): void => {
   const evtCtx = event.context! // Context should be set earlier in the flow

package/src/core/page/get-page-context.ts

@@ -1,7 +1,7 @@
 import { isPlainObject } from '@ht-sdks/events-sdk-js-core'
 
 /**
- * Final Page Context object expected in the Segment Event context
+ * Final Page Context object expected in the Hightouch Event context
  */
 export interface PageContext {
   path: string

package/src/core/stats/remote-metrics.ts

@@ -11,7 +11,7 @@ export interface MetricsOptions {
 }
 
 /**
- * Type expected by the segment metrics API endpoint
+ * Type expected by the hightouch metrics API endpoint
  */
 type RemoteMetric = {
   type: 'Counter'

package/src/core/user/index.ts

@@ -21,6 +21,7 @@ import {
   hasSessionExpired,
   updateSessionExpiration,
 } from '../session'
+import type { HTTPCookieService } from '../http-cookies'
 
 export type ID = string | null | undefined
 
@@ -32,6 +33,11 @@ export interface UserOptions {
   localStorageFallbackDisabled?: boolean
   persist?: boolean
 
+  /**
+   * Replicates "BrowserCookie" actions against a matching "ServerCookie".
+   */
+  httpCookieService?: HTTPCookieService
+
   cookie?: {
     key?: string
     oldKey?: string
@@ -145,11 +151,22 @@ export class User {
     const prevId = this.identityStore.getAndSync(this.idKey)
 
     if (id !== undefined) {
+      const clearingIdentity = id === null
+      const changingIdentity = id !== prevId && prevId !== null && id !== null
+      const creatingIdentity = id !== prevId && prevId === null && id !== null
+
       this.identityStore.set(this.idKey, id)
 
-      const changingIdentity = id !== prevId && prevId !== null && id !== null
+      if (clearingIdentity) {
+        this.options?.httpCookieService?.dispatchClear()
+      }
+
       if (changingIdentity) {
-        this.anonymousId(null)
+        this.anonymousId(null) // this also runs dispatchClear()
+      }
+
+      if (changingIdentity || creatingIdentity) {
+        this.options?.httpCookieService?.dispatchCreate()
       }
     }
 
@@ -176,28 +193,36 @@ export class User {
 
     if (id === undefined) {
       let val = this.identityStore.getAndSync(this.anonKey)
+      let migrated = false
 
       // support anonymousId migration from other analytics providers
       if (!val) {
         val = decryptRudderHtValue(
           this.identityStore.getAndSync(rudderHtAnonymousIdKey) ?? ''
         )
+        migrated = Boolean(val)
         if (val) this.identityStore.set(this.anonKey, val)
       }
       if (!val) {
         val = this.identityStore.getAndSync(segmentAnonymousIdKey)
+        migrated = Boolean(val)
         if (val) this.identityStore.set(this.anonKey, val)
       }
       if (!val) {
         val = decryptRudderValue(
           this.identityStore.getAndSync(rudderAnonymousIdKey) ?? ''
         )
+        migrated = Boolean(val)
         if (val) this.identityStore.set(this.anonKey, val)
       }
       if (!val) {
         val = this.legacySIO()?.[0] ?? null
       }
 
+      if (migrated) {
+        this.options?.httpCookieService?.dispatchCreate()
+      }
+
       if (val) {
         return val
       }
@@ -205,11 +230,16 @@ export class User {
 
     if (id === null) {
       this.identityStore.set(this.anonKey, null)
-      return this.identityStore.getAndSync(this.anonKey)
+      const clearedVal = this.identityStore.getAndSync(this.anonKey)
+      this.options?.httpCookieService?.dispatchClear()
+      return clearedVal
     }
 
     this.identityStore.set(this.anonKey, id ?? uuid())
-    return this.identityStore.getAndSync(this.anonKey)
+    const syncedVal = this.identityStore.getAndSync(this.anonKey)
+
+    this.options?.httpCookieService?.dispatchCreate()
+    return syncedVal
   }
 
   traits = (traits?: Traits | null): Traits | undefined => {

package/src/generated/version.ts

@@ -1,2 +1,2 @@
 // This file is generated.
-export const version = '1.0.4'
+export const version = '1.2.0'

package/src/index.ts

@@ -7,7 +7,7 @@ export * from './core/events'
 export * from './core/plugin'
 export * from './core/user'
 
-export type { AnalyticsSnippet } from './browser/standalone-interface'
+export type { HtEventsSnippet } from './browser/standalone-interface'
 export type { MiddlewareFunction } from './plugins/middleware'
 export { getGlobalAnalytics } from './lib/global-analytics-helper'
 export { UniversalStorage, Store, StorageObject } from './core/storage'

package/src/lib/global-analytics-helper.ts

@@ -1,4 +1,4 @@
-import { AnalyticsSnippet } from '../browser/standalone-interface'
+import { HtEventsSnippet } from '../browser/standalone-interface'
 
 /**
  * Stores the global window analytics key
@@ -8,9 +8,9 @@ let _globalAnalyticsKey = 'htevents'
 /**
  * Gets the global analytics/buffer
  * @param key name of the window property where the buffer is stored (default: analytics)
- * @returns AnalyticsSnippet
+ * @returns HtEventsSnippet
  */
-export function getGlobalAnalytics(): AnalyticsSnippet | undefined {
+export function getGlobalAnalytics(): HtEventsSnippet | undefined {
   return (window as any)[_globalAnalyticsKey]
 }
 
@@ -26,6 +26,6 @@ export function setGlobalAnalyticsKey(key: string) {
  * Sets the global analytics object
  * @param analytics analytics snippet
  */
-export function setGlobalAnalytics(analytics: AnalyticsSnippet): void {
+export function setGlobalAnalytics(analytics: HtEventsSnippet): void {
   ;(window as any)[_globalAnalyticsKey] = analytics
 }

package/src/lib/merged-options.ts

@@ -5,7 +5,7 @@ import { LegacySettings } from '../browser'
  * Merge legacy settings and initialized Integration option overrides.
  *
  * This will merge any options that were passed from initialization into
- * overrides for settings that are returned by the Segment CDN.
+ * overrides for settings that are returned by the Hightouch CDN.
  *
  * i.e. this allows for passing options directly into destinations from
  * the Analytics constructor.

package/src/lib/parse-cdn.ts

@@ -45,7 +45,7 @@ export const getCDN = (): string => {
     // it's possible that the CDN is not found in the page because:
     // - the script is loaded through a proxy
     // - the script is removed after execution
-    // in this case, we fall back to the default Segment CDN
+    // in this case, we fall back to the default Hightouch CDN
     return `https://cdn.hightouch-events.com`
   }
 }

package/src/lib/to-facade.ts

@@ -8,13 +8,16 @@ import {
   Screen,
   Track,
 } from '@segment/facade'
-import { SegmentEvent } from '../core/events'
+import { HightouchEvent } from '../core/events'
 
-export type SegmentFacade = Facade<SegmentEvent> & {
-  obj: SegmentEvent
+export type SegmentFacade = Facade<HightouchEvent> & {
+  obj: HightouchEvent
 }
 
-export function toFacade(evt: SegmentEvent, options?: Options): SegmentFacade {
+export function toFacade(
+  evt: HightouchEvent,
+  options?: Options
+): SegmentFacade {
   let fcd = new Facade(evt, options)
 
   if (evt.type === 'track') {

package/src/node/index.ts

@@ -20,7 +20,7 @@ export class AnalyticsNode {
 
     const nodeSettings = {
       writeKey: settings.writeKey,
-      name: 'analytics-node-next',
+      name: 'events-sdk-js-node',
       type: 'after' as Plugin['type'],
       version: 'latest',
     }

package/src/plugins/ajs-destination/types.ts

@@ -18,7 +18,7 @@ export interface LegacyIntegration extends Emitter {
   alias?: (event: Alias) => void | Promise<void>
   group?: (event: Group) => void | Promise<void>
 
-  // Segment.io specific
+  // Hightouch.io specific
   ontrack?: (event: Track) => void | Promise<void>
   onidentify?: (event: Identify) => void | Promise<void>
   onpage?: (event: Page) => void | Promise<void>

package/src/plugins/ajs-destination/utils.ts

@@ -15,7 +15,7 @@ export const isInstallableIntegration = (
   // checking for iterable is a quick fix we need in place to prevent
   // errors showing Iterable as a failed destiantion. Ideally, we should
   // fix the Iterable metadata instead, but that's a longer process.
-  return !name.startsWith('Segment') && name !== 'Iterable' && deviceMode
+  return !name.startsWith('Hightouch') && name !== 'Iterable' && deviceMode
 }
 
 export const isDisabledIntegration = (

package/src/plugins/analytics-node/index.ts

@@ -1,6 +1,6 @@
 import { Plugin } from '../../core/plugin'
 import { Context } from '../../core/context'
-import { SegmentEvent } from '../../core/events'
+import { HightouchEvent } from '../../core/events'
 import fetch from 'node-fetch'
 import { version } from '../../generated/version'
 
@@ -14,16 +14,16 @@ interface AnalyticsNodeSettings {
 const btoa = (val: string): string => Buffer.from(val).toString('base64')
 
 export async function post(
-  event: SegmentEvent,
+  event: HightouchEvent,
   writeKey: string
-): Promise<SegmentEvent> {
+): Promise<HightouchEvent> {
   const res = await fetch(
     `https://us-east-1.hightouch-events.com/v1/${event.type}`,
     {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        'User-Agent': 'analytics-node-next/latest',
+        'User-Agent': 'events-sdk-js-node/latest',
         Authorization: `Basic ${btoa(writeKey)}`,
       },
       body: JSON.stringify(event),
@@ -39,7 +39,7 @@ export async function post(
 
 export function analyticsNode(settings: AnalyticsNodeSettings): Plugin {
   const send = async (ctx: Context): Promise<Context> => {
-    ctx.updateEvent('context.library.name', 'analytics-node-next')
+    ctx.updateEvent('context.library.name', 'events-sdk-js-node')
     ctx.updateEvent('context.library.version', version)
     ctx.updateEvent('_metadata.nodeVersion', process.versions.node)
 

package/src/plugins/env-enrichment/index.ts

@@ -2,7 +2,7 @@ import jar from 'js-cookie'
 import type { Context } from '../../core/context'
 import type { Plugin } from '../../core/plugin'
 import { version } from '../../generated/version'
-import { SegmentEvent } from '../../core/events'
+import { HightouchEvent } from '../../core/events'
 import { Campaign, PluginType } from '@ht-sdks/events-sdk-js-core'
 import { getVersionType } from '../../lib/version-type'
 import { tld } from '../../core/user/tld'
@@ -84,7 +84,7 @@ export function ampId(): string | undefined {
 
 function referrerId(
   query: string,
-  ctx: SegmentEvent['context'],
+  ctx: HightouchEvent['context'],
   disablePersistance: boolean
 ): void {
   const storage = new UniversalStorage<{

package/src/plugins/hightouchio/batched-dispatcher.ts

@@ -1,4 +1,4 @@
-import { SegmentEvent } from '../../core/events'
+import { HightouchEvent } from '../../core/events'
 import { fetch } from '../../lib/fetch'
 import { onPageChange } from '../../lib/on-page-change'
 
@@ -59,11 +59,11 @@ export default function batch(
       return
     }
 
-    const writeKey = (batch[0] as SegmentEvent)?.writeKey
+    const writeKey = (batch[0] as HightouchEvent)?.writeKey
 
     // Remove sentAt from every event as batching only needs a single timestamp
     const updatedBatch = batch.map((event) => {
-      const { sentAt, ...newEvent } = event as SegmentEvent
+      const { sentAt, ...newEvent } = event as HightouchEvent
       return newEvent
     })