@vrplatform/log 2.0.0-alpha.4 → 2.0.0-alpha.40

package/src/tracking/index.ts

@@ -1,56 +1,152 @@
+declare module 'intercom-client' {
+  export namespace Intercom {
+    export interface CreateContactRequestWithExternalId {
+      /** A unique identifier for the contact which is given to Intercom */
+      external_id: string;
+      /** The contacts phone */
+      phone?: string;
+      /** The contacts name */
+      name?: string;
+      /** An image URL containing the avatar of a contact */
+      avatar?: string;
+      /** The time specified for when a contact signed up */
+      signed_up_at?: number;
+      /** The time when the contact was last seen (either where the Intercom Messenger was installed or when specified manually) */
+      last_seen_at?: number;
+      /** The id of an admin that has been assigned account ownership of the contact */
+      owner_id?: number;
+      /** Whether the contact is unsubscribed from emails */
+      unsubscribed_from_emails?: boolean;
+      /** The custom attributes which are set for the contact */
+      custom_attributes?: ContactCustomAttributes;
+    }
+    interface UpdateContactRequest {
+      /** The role of the contact. */
+      role?: 'user' | 'lead';
+      /** A unique identifier for the contact which is given to Intercom */
+      external_id?: string;
+      /** The contacts email */
+      email?: string;
+      /** The contacts phone */
+      phone?: string;
+      /** The contacts name */
+      name?: string;
+      /** An image URL containing the avatar of a contact */
+      avatar?: string;
+      /** The time specified for when a contact signed up */
+      signed_up_at?: number;
+      /** The time when the contact was last seen (either where the Intercom Messenger was installed or when specified manually) */
+      last_seen_at?: number;
+      /** The id of an admin that has been assigned account ownership of the contact */
+      owner_id?: number;
+      /** Whether the contact is unsubscribed from emails */
+      unsubscribed_from_emails?: boolean;
+      /** The custom attributes which are set for the contact */
+      custom_attributes?: ContactCustomAttributes;
+    }
+    interface ContactCustomAttributes {
+      Onboarding_Support?: string; // The customer's preferred onboarding level
+      userType?: string; // User Type (user or owner)
+      // ARCHIVED
+      // article_id?: string; // undefined
+      // workflowInstanceId?: number; // undefined
+      // Active_Listings?: string; // The number of active listings a user has
+      // Accounting_Software?: string; // The client's accounting software
+    }
+    interface CreateOrUpdateCompanyRequest {
+      /** The name of the Company */
+      name?: string;
+      /** The company id you have defined for the company. Can't be updated */
+      company_id?: string;
+      /** The name of the plan you have associated with the company. */
+      plan?: string;
+      /** The number of employees in this company. */
+      size?: number;
+      /** The URL for this company's website. Please note that the value specified here is not validated. Accepts any string. */
+      website?: string;
+      /** The industry that this company operates in. */
+      industry?: string;
+      /** A hash of key/value pairs containing any other data about the company you want Intercom to store. */
+      custom_attributes?: CompanyCustomAttributes;
+      /** The time the company was created by you. */
+      remote_created_at?: number;
+      /** How much revenue the company generates for your business. Note that this will truncate floats. i.e. it only allow for whole integers, 155.98 will be truncated to 155. Note that this has an upper limit of 2\*\*31-1 or 2147483647.. */
+      monthly_spend?: number;
+    }
+    interface CompanyCustomAttributes {
+      teamId?: string; // undefined
+      team?: string; // undefined
+      type?: string; // undefined
+      status?: string; // undefined
+      pms?: string; // undefined
+      accountingSoftware?: string; // Accounting software used by the team.
+      creation_source?: string; // undefined
+      activeListings?: number; // Active Listings
+      paymentMethodType?: string; // Payment Method
+      partnerName?: string; // Partner Name
+      billingPortalUrl?: string; // Billing Portal URL
+      billingStatus?: string; // undefined
+      billingPartner?: string; // Name of billing partner
+      // ARCHIVED
+      // firstName?: string; // undefined
+      // lastName?: string; // undefined
+      // email?: string; // undefined
+      // apps?: string; // All active connections besides pms/accounting
+      // accountingPartner?: string; // Name of accounting partner
+      // 'SaaS User'?: boolean; // undefined
+    }
+  }
+}
+
 import { Analytics } from '@june-so/analytics-node';
+import { Intercom, IntercomClient } from 'intercom-client';
+import { fetcher } from 'intercom-client/core/fetcher/Fetcher';
 import { PostHog } from 'posthog-node';
-import { useLog } from '../log';
-import { useIntercom } from './intercom';
-
-const E2E_TEST_USERS = [
-  '9e7dfc88-503c-4222-9905-9116169d2203', // lars+checkly@finalytic.co
-  '113d73d8-ee21-46b7-a12a-a74f632401ca', // e2e-invite-member@finalytic.io
-  '917b7c4e-cb03-491c-9e94-d33a5bdeca05', // e2e-invite-owner@finalytic.io
-  'ec8e5572-74d0-4ae6-af73-bca8db9a27e9', // e2e-sign-up@finalytic.io
-];
-const E2E_TEST_TEAMS = [
-  'c4fd21b4-8447-43a2-bdcb-f06a85a935ad', // VRP Automated Testing
-  '8f21060e-afe6-410a-b2f4-00a3caa20786', // test_company_xxxx
-];
-
-const isTest = (userId: string, groupId?: string) =>
-  E2E_TEST_USERS.includes(userId) ||
-  (groupId && E2E_TEST_TEAMS.includes(groupId));
-
-export type TrackingProps = {
-  name: string;
-  dataset: string;
-  env: {
-    INTERCOM_TOKEN: string;
-    JUNESO_ANALYTICS_WRITE_KEY: string;
-    POSTHOG_API_KEY: string;
-  };
-};
-export type Tracking = ReturnType<typeof useTracking>;
+import { type WorkerLog, useLog } from '../log';
+import { convertKeysToSnakeCase, isTest } from '../utils';
+import { convertValuesToString } from '../utils/convertValuesToString';
+import type {
+  GroupProps,
+  IdentifyProps,
+  TrackProps,
+  TrackingProps,
+} from './types';
 
-type OptionalUser<T> = T &
-  (
-    | { userId: string; anonymousId?: string }
-    | {
-        userId?: string;
-        anonymousId: string;
-      }
-  );
+export * from './types';
+export * from 'intercom-client';
+
+export type Tracking = ReturnType<typeof useTracking>;
 
 export const useTracking = (
   { dataset, env, name }: TrackingProps,
   isDev?: boolean
-) => {
-  const axiom = useLog({ name, dataset, env });
+): {
+  track: (props: TrackProps) => Promise<void>;
+  identify: (props: IdentifyProps) => Promise<void>;
+  group: (props: GroupProps) => Promise<void>;
+  shutdown: () => Promise<any>;
+  log: WorkerLog;
+  june?: Analytics;
+  intercom?: IntercomClient;
+  posthog?: PostHog;
+} => {
+  const log = useLog({ name, dataset, env });
+
   const intercom = env.INTERCOM_TOKEN
-    ? useIntercom(env.INTERCOM_TOKEN, axiom)
-    : undefined;
-  const juneso = env.JUNESO_ANALYTICS_WRITE_KEY
-    ? new Analytics(env.JUNESO_ANALYTICS_WRITE_KEY)
+    ? new IntercomClient({
+        token: env.INTERCOM_TOKEN,
+        fetcher: (args) =>
+          fetcher({
+            ...args,
+            headers: { ...args.headers, accept: 'application/json' },
+          }),
+      })
     : undefined;
-  const posthog = env.POSTHOG_API_KEY
-    ? new PostHog(env.POSTHOG_API_KEY, {
+
+  const june = env.JUNESO_TOKEN ? new Analytics(env.JUNESO_TOKEN) : undefined;
+
+  const posthog = env.POSTHOG_TOKEN
+    ? new PostHog(env.POSTHOG_TOKEN, {
         host: 'https://app.posthog.com',
       })
     : undefined;
@@ -59,94 +155,218 @@ export const useTracking = (
     // General
     track: async ({
       userId,
+      anonymousId,
       groupId,
       event,
       properties,
-    }: {
-      userId: string;
-      groupId: string;
-      event: string;
-      properties: Record<string, any>;
-    }) => {
-      if (isDev || isTest(userId, groupId)) return;
-
-      posthog?.capture({
-        distinctId: userId,
-        event,
-        groups: {
-          tenant: groupId,
-        },
-        properties,
-      });
-      juneso?.track({
-        userId,
-        event,
-        properties,
-        context: { groupId },
-      });
+      timestamp,
+    }: TrackProps) => {
+      if (isDev || isTest(userId || anonymousId || '', groupId)) return;
 
-      try {
-        await intercom?.trackEvent({
-          user_id: userId,
-          event_name: event,
-          metadata: properties,
+      if (anonymousId) {
+        posthog?.capture({
+          distinctId: anonymousId,
+          event,
+          groups: {
+            tenant: groupId,
+          },
+          timestamp,
+          properties: convertKeysToSnakeCase(properties),
         });
-      } catch (error: any) {
-        console.error(error);
+
+        june?.track(
+          {
+            anonymousId,
+            event,
+            properties,
+            timestamp,
+            context: { groupId },
+          },
+          (err) => {
+            if (err) console.error(err);
+          }
+        );
+
+        // no intercom for anonymous
+      } else if (userId) {
+        posthog?.capture({
+          distinctId: userId,
+          event,
+          groups: {
+            tenant: groupId,
+          },
+          timestamp,
+          properties: convertKeysToSnakeCase(properties),
+        });
+
+        june?.track(
+          {
+            userId,
+            event,
+            properties,
+            timestamp,
+            context: { groupId },
+          },
+          (err) => {
+            if (err) console.error(err);
+          }
+        );
+
+        const intercomUserId = (
+          await intercom?.contacts.search({
+            query: {
+              field: 'external_id',
+              operator: Intercom.SingleFilterSearchRequestOperator.Equals,
+              value: userId,
+            },
+          })
+        )?.data.at(0)?.id;
+        if (intercomUserId)
+          await intercom?.events.create({
+            user_id: intercomUserId,
+            event_name: event,
+            metadata: convertValuesToString(properties),
+            created_at: timestamp ? timestamp.getTime() : Date.now(),
+          });
       }
     },
-    identify: ({
+    identify: async ({
       traits,
       userId,
       disableGeoip,
-    }: {
-      userId: string;
-      traits: Record<string, any>;
-      disableGeoip?: boolean;
-    }) => {
+      timestamp,
+    }: IdentifyProps) => {
       if (isDev || isTest(userId)) return;
 
       posthog?.identify({
         distinctId: userId,
-        properties: traits,
+        properties: convertKeysToSnakeCase(traits),
         disableGeoip,
       });
-      juneso?.identify({
-        userId,
-        traits,
-      });
+
+      june?.identify(
+        {
+          userId,
+          traits,
+          timestamp,
+        },
+        (err) => (err ? console.error(err) : {})
+      );
+
+      // upsert intercom user
+      const data = {
+        external_id: userId,
+        email: traits?.email,
+        name:
+          traits?.name ||
+          (traits?.firstName
+            ? `${traits.firstName} ${traits.lastName}`
+            : traits?.lastName),
+        avatar: traits?.avatar,
+        signed_up_at: traits?.createdAt
+          ? new Date(traits.createdAt).getTime() / 1000
+          : undefined,
+        last_seen_at: new Date().getTime() / 1000,
+        custom_attributes: { userType: traits?.role },
+      };
+
+      const intercomUser = (
+        await intercom?.contacts.search({
+          query: {
+            field: 'external_id',
+            operator: Intercom.SingleFilterSearchRequestOperator.Equals,
+            value: userId,
+          },
+        })
+      )?.data.at(0);
+      if (intercomUser?.id)
+        await intercom?.contacts.update(intercomUser?.id, data);
+      else await intercom?.contacts.create(data);
     },
-    group: ({
+    group: async ({
       traits,
       groupId,
       userId,
       anonymousId,
-    }: OptionalUser<{
-      groupId: string;
-      traits?: Record<string, any>;
-    }>) => {
+      timestamp,
+    }: GroupProps) => {
       if (isDev || isTest(userId || anonymousId || '', groupId)) return;
 
-      posthog?.groupIdentify({
-        groupKey: groupId,
-        groupType: 'tenant',
-        properties: traits,
-        distinctId: userId,
+      const cid = traits?.billingCustomerId || traits?.hyperlineCustomerId;
+      const intercomCompany = await intercom?.companies.create({
+        name: traits?.name,
+        company_id: groupId,
+        // plan: string;
+        remote_created_at: traits?.createdAt
+          ? new Date(traits.createdAt).getTime() / 1000
+          : undefined,
+        // monthly_spend: number;
+        custom_attributes: {
+          teamId: groupId,
+          team: traits?.name,
+          type: traits?.type,
+          status: traits?.status,
+          pms: traits?.pms,
+          accountingSoftware: traits?.accountingSoftware,
+          activeListings: traits?.activeListings,
+          // paymentMethodType: string; // Payment Method
+          partnerName: traits?.partner || traits?.accountingPartner,
+          billingPortalUrl: cid
+            ? `https://billing.vrplatform.app/portal/${cid}`
+            : undefined,
+          billingStatus: traits?.billingSubscriptionStatus,
+          billingPartner:
+            traits?.billingPartner ||
+            traits?.partner ||
+            traits?.accountingPartner,
+        },
       });
-      if (anonymousId) juneso?.group({ anonymousId, groupId, traits });
-      else if (userId) juneso?.group({ userId, groupId, traits });
+
+      if (anonymousId) {
+        posthog?.groupIdentify({
+          groupKey: groupId,
+          groupType: 'tenant',
+          properties: convertKeysToSnakeCase(traits),
+          distinctId: anonymousId,
+        });
+
+        june?.group({ anonymousId, groupId, traits, timestamp }, (err) =>
+          err ? console.error(err) : {}
+        );
+      } else if (userId) {
+        posthog?.groupIdentify({
+          groupKey: groupId,
+          groupType: 'tenant',
+          properties: convertKeysToSnakeCase(traits),
+          distinctId: userId,
+        });
+
+        june?.group({ userId, groupId, traits, timestamp }, (err) =>
+          err ? console.error(err) : {}
+        );
+
+        // attach intercom user to intercom company
+        const intercomUser = (
+          await intercom?.contacts.search({
+            query: {
+              field: 'external_id',
+              operator: Intercom.SingleFilterSearchRequestOperator.Equals,
+              value: userId,
+            },
+          })
+        )?.data.at(0);
+        if (intercomUser?.id && intercomCompany?.id)
+          intercom?.companies.attachContact(intercomUser?.id, {
+            id: intercomCompany?.id,
+          });
+      }
     },
     shutdown: async () =>
-      Promise.all([
-        posthog?.shutdown(),
-        juneso?.closeAndFlush(),
-        axiom.flush(),
-      ]),
-    // Posthog specific
-    alias: posthog?.alias,
-    isFeatureEnabled: posthog?.isFeatureEnabled,
-    // export intercom and axiom
+      Promise.all([posthog?.shutdown(), june?.closeAndFlush(), log?.flush()]),
+    // export dependencies
     intercom,
-    log: axiom,
+    posthog,
+    june,
+    log,
   };
 };

package/src/tracking/types.ts

@@ -0,0 +1,181 @@
+import type { LogBindings } from '../log';
+
+type AuthEvent =
+  | 'account_signin_completed'
+  | 'account_signup_code_requested'
+  | 'account_signup_code_completed'
+  | 'account_signup_code_failed'
+  | 'account_signup_completed'
+  | 'account_password_reset_requested'
+  | 'account_password_reset_failed'
+  | 'account_password_reset_completed'
+  | 'account_invitation_accepted'
+  | 'account_signed_out';
+
+type TeamEvent =
+  | 'team_added'
+  | 'team_info_updated'
+  | 'team_deleted'
+  | 'team_member_removed';
+
+type ConnectionEvent =
+  | 'connection_created'
+  | 'connection_reconnected'
+  | 'connection_deleted'
+  | 'connection_requested';
+
+type OwnershipEvent =
+  | 'ownership_created'
+  | 'ownership_updated'
+  | 'ownership_deleted';
+
+type OwnerEvent =
+  | 'owner_created'
+  | 'owner_updated'
+  | 'owner_deleted'
+  | 'owner_tax_info_modal_opened'
+  | 'owner_tax_info_modal_submitted';
+
+type SetupEvent =
+  | 'setup_classes_set'
+  | 'setup_accounting_version_completed'
+  | 'setup_accounting_config_completed'
+  | 'setup_owner_imported'
+  | 'setup_listing_imported';
+
+type AutomationEvent =
+  | 'automation_created'
+  | 'automation_updated'
+  | 'automation_deleted';
+
+type TaxStatementEvent =
+  | 'tax_statement_preview_opened'
+  | 'tax_statement_downloaded';
+
+type GLOwnerStatementEvent =
+  | 'gl_owner_statement_preview_opened'
+  | 'gl_owner_statement_downloaded';
+
+type HyperlineEvent =
+  | 'hyperline_invoice_ready'
+  | 'hyperline_invoice_settled'
+  | 'hyperline_trial_started'
+  | 'hyperline_trial_ended'
+  | 'hyperline_subscription_activated'
+  | 'hyperline_subscription_cancelled'
+  | 'hyperline_subscription_created'
+  | 'hyperline_subscription_errored'
+  | 'hyperline_subscription_paused'
+  | 'hyperline_subscription_voided'
+  | 'hyperline_subscription_charged'
+  | 'hyperline_customer_created'
+  | 'hyperline_customer_updated'
+  | 'hyperline_payment_method_created'
+  | 'hyperline_payment_method_errored'
+  | 'hyperline_payment_method_deleted';
+
+type ListingEvent = 'listing_activated' | 'listing_deactivated';
+
+type ReportEvent = 'listings_reported';
+
+type UserEvent = 'update_refresh_accepted' | 'owner_statement_opened';
+
+type TestEvent = 'test_event' | 'test_error';
+
+export type TrackingEvent =
+  | AuthEvent
+  | TeamEvent
+  | ConnectionEvent
+  | OwnershipEvent
+  | OwnerEvent
+  | SetupEvent
+  | AutomationEvent
+  | TaxStatementEvent
+  | GLOwnerStatementEvent
+  | HyperlineEvent
+  | UserEvent
+  | ListingEvent
+  | ReportEvent
+  | TestEvent;
+
+export type TrackingProps = {
+  name: string;
+  dataset: string;
+  env: {
+    INTERCOM_TOKEN?: string;
+    JUNESO_TOKEN?: string;
+    POSTHOG_TOKEN?: string;
+  } & LogBindings;
+  debugging?: boolean;
+};
+
+export type TrackProps = OptionalUser<{
+  groupId: string;
+  event: TrackingEvent;
+  properties: Record<string, string | number | boolean | null | undefined>;
+  timestamp?: Date;
+}>;
+export type IdentifyProps = {
+  userId: string;
+  traits?: {
+    id?: string;
+    email?: string;
+    avatar?: string;
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    createdAt?: string;
+    country?: string;
+    isSuperAdmin?: boolean;
+    isVrpAdmin?: boolean;
+    isPartnerAdmin?: boolean;
+    isTeamAdmin?: boolean;
+    role?: UserRole;
+    [key: string]: string | number | boolean | null | undefined;
+  };
+  disableGeoip?: boolean;
+  timestamp?: Date;
+};
+export type GroupProps = OptionalUser<{
+  groupId: string;
+  traits?: {
+    name?: string;
+    type?: TenantType;
+    avatar?: string;
+    createdAt?: string;
+    partner?: string;
+    partnerId?: string;
+    billingCustomerId?: string;
+    billingSubscriptionStatus?: string; // todo: update type as enum
+    status?: TenantStatus;
+    isOnboarding?: boolean;
+    accountingPartner?: string;
+    billingPartner?: string;
+    pms?: string;
+    apps?: string;
+    accountingSoftware?: string;
+    activeListings?: number;
+    [key: string]: string | number | boolean | null | undefined;
+  };
+  timestamp?: Date;
+}>;
+
+export type UserRole =
+  | 'super-admin'
+  | 'vrp-admin'
+  | 'partner-admin'
+  | 'team-admin'
+  | 'admin'
+  | 'owner'
+  | 'user';
+export type TenantType = 'admin' | 'partner' | 'propertyManager';
+export type TenantStatus = 'active' | 'inactive';
+
+type OptionalUser<T> = T &
+  (
+    | { userId: string; anonymousId?: string }
+    | {
+        userId?: string;
+        anonymousId: string;
+      }
+  );

package/src/utils/convertKeysToSnakeCase.ts

@@ -0,0 +1,21 @@
+export const convertKeysToSnakeCase = (obj?: Record<string, any>) => {
+  const result: Record<string, any> = {};
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+  for (const key in obj) {
+    if (hasOwnProperty.call(obj, key)) {
+      const snakeKey = key.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+      if (
+        typeof obj[key] === 'object' &&
+        !Array.isArray(obj[key]) &&
+        obj[key] !== null
+      ) {
+        result[snakeKey] = convertKeysToSnakeCase(obj[key]);
+      } else {
+        result[snakeKey] = obj[key];
+      }
+    }
+  }
+
+  return result;
+};

package/src/utils/convertValuesToString.ts

@@ -0,0 +1,10 @@
+export function convertValuesToString(obj: { [key: string]: any }): {
+  [key: string]: string;
+} {
+  const result: { [key: string]: string } = {};
+
+  for (const key of Object.keys(obj))
+    if (obj[key] !== undefined) result[key] = obj[key].toString();
+
+  return result;
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './convertKeysToSnakeCase';
+export * from './convertValuesToString';
+export * from './isTest';