@formo/analytics 1.11.5 → 1.11.6-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formo/analytics",
-  "version": "1.11.5",
+  "version": "1.11.6-alpha.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/getformo/sdk.git"

package/src/FormoAnalytics.ts

@@ -1,24 +1,18 @@
 import axios from 'axios';
 import {
   COUNTRY_LIST,
-  EVENTS_API,
+  EVENTS_API_URL,
   SESSION_STORAGE_ID_KEY,
   Event,
 } from './constants';
-import { isNotEmpty } from './utils';
 import { H } from 'highlight.run';
-import { ChainID, EIP1193Provider, RequestArguments } from './types';
+import { ChainID, EIP1193Provider, Options } from './types';
 
 interface IFormoAnalytics {
   /**
    * Initializes the FormoAnalytics instance with the provided API key and project ID.
    */
-  init(apiKey: string, projectId: string): Promise<FormoAnalytics>;
-
-  /**
-   * Identifies the user with the provided user data.
-   */
-  identify(userData: Record<string, any>): void;
+  init(apiKey: string, options: Options): Promise<FormoAnalytics>;
 
   /**
    * Tracks page visit events.
@@ -28,22 +22,25 @@ interface IFormoAnalytics {
   /**
    * Connects to a wallet with the specified chain ID and address.
    */
-  connect(params: { account: string; chainId: ChainID }): Promise<void>;
+  connect(params: { chainId: ChainID; address: string }): Promise<void>;
 
   /**
    * Disconnects the current wallet and clears the session information.
    */
-  disconnect(attributes?: { account?: string; chainId?: ChainID }): void;
+  disconnect(params?: { chainId?: ChainID; address?: string }): void;
 
   /**
-   * Tracks a specific event with a name and associated data.
+   * Switches the blockchain chain context and optionally logs additional params.
    */
-  track(eventName: string, eventData: Record<string, any>): void;
+  chain(params: { chainId: ChainID; address?: string }): void;
 
   /**
-   * Switches the blockchain chain context and optionally logs additional attributes.
+   * Tracks a specific event with a name and associated data.
    */
-  chain(attributes: { chainId: ChainID; account?: string }): void;
+  track(eventName: string, eventData: Record<string, any>): void;
+}
+interface Config {
+  token: string;
 }
 export class FormoAnalytics implements IFormoAnalytics {
   private _provider?: EIP1193Provider;
@@ -52,36 +49,34 @@ export class FormoAnalytics implements IFormoAnalytics {
     (...args: unknown[]) => void
   > = {};
 
-  private sessionKey = 'walletAddress';
-  private config: any;
+  private walletAddressSessionKey = 'walletAddress';
+  private config: Config;
   private sessionIdKey: string = SESSION_STORAGE_ID_KEY;
   private timezoneToCountry: Record<string, string> = COUNTRY_LIST;
 
   currentChainId?: string | null;
-  currentConnectedAccount?: string;
+  currentConnectedAddress?: string;
 
   private constructor(
     public readonly apiKey: string,
-    public projectId: string
+    public options: Options = {}
   ) {
     this.config = {
       token: this.apiKey,
     };
 
-    const provider = window?.ethereum || window.web3?.currentProvider;
+    const provider =
+      window?.ethereum || window.web3?.currentProvider || options?.provider;
     if (provider) {
       this.trackProvider(provider);
     }
   }
 
-  static async init(
-    apiKey: string,
-    projectId: string
-  ): Promise<FormoAnalytics> {
+  static async init(apiKey: string, options: Options): Promise<FormoAnalytics> {
     const config = {
       token: apiKey,
     };
-    const instance = new FormoAnalytics(apiKey, projectId);
+    const instance = new FormoAnalytics(apiKey, options);
     instance.config = config;
 
     return instance;
@@ -91,10 +86,6 @@ export class FormoAnalytics implements IFormoAnalytics {
     return this._provider;
   }
 
-  private identifyUser(userData: any) {
-    this.trackEvent(Event.IDENTIFY, userData);
-  }
-
   private getSessionId() {
     const existingSessionId = this.getCookieValue(this.sessionIdKey);
 
@@ -106,13 +97,16 @@ export class FormoAnalytics implements IFormoAnalytics {
     return newSessionId;
   }
 
+  private getOrigin(): string {
+    return window.location.origin || 'ORIGIN_NOT_FOUND';
+  }
+
   // Function to set the session cookie
-  private setSessionCookie(domain?: string) {
+  private setSessionCookie(): void {
     const sessionId = this.getSessionId();
-    let cookieValue = `${this.sessionIdKey}=${sessionId}; Max-Age=1800; path=/; secure`;
-    if (domain) {
-      cookieValue += `; domain=${domain}`;
-    }
+    let cookieValue = `${
+      this.sessionIdKey
+    }=${sessionId}; Max-Age=1800; path=/; secure; domain=${this.getOrigin()}`;
     document.cookie = cookieValue;
   }
 
@@ -136,27 +130,32 @@ export class FormoAnalytics implements IFormoAnalytics {
     const maxRetries = 3;
     let attempt = 0;
 
-    this.setSessionCookie(this.config.domain);
-    const apiUrl = this.buildApiUrl();
+    this.setSessionCookie();
     const address = await this.getCurrentWallet();
 
+    console.log('address:', address);
+
     const requestData = {
-      project_id: this.projectId,
       address: address,
       session_id: this.getSessionId(),
       timestamp: new Date().toISOString(),
-      action: action,
+      action,
       version: '1',
-      payload: isNotEmpty(payload) ? this.maskSensitiveData(payload) : payload,
+      payload,
     };
 
     const sendRequest = async (): Promise<void> => {
       try {
-        const response = await axios.post(apiUrl, JSON.stringify(requestData), {
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        });
+        const response = await axios.post(
+          EVENTS_API_URL,
+          JSON.stringify(requestData),
+          {
+            headers: {
+              'Content-Type': 'application/json',
+              Authorization: `Bearer ${this.apiKey}`,
+            },
+          }
+        );
 
         if (response.status >= 200 && response.status < 300) {
           console.log('Event sent successfully:', action);
@@ -189,72 +188,6 @@ export class FormoAnalytics implements IFormoAnalytics {
     await sendRequest();
   }
 
-  // Function to mask sensitive data in the payload
-  private maskSensitiveData(
-    data: string | undefined | null
-  ): Record<string, any> | null {
-    // Check if data is null or undefined
-    if (data === null || data === undefined) {
-      console.warn('Data is null or undefined, returning null');
-      return null;
-    }
-
-    // Check if data is a string; if so, parse it to an object
-    if (typeof data === 'string') {
-      let parsedData: Record<string, any>;
-      try {
-        parsedData = JSON.parse(data);
-      } catch (error) {
-        console.error('Failed to parse JSON:', error);
-        return null; // Return null if parsing fails
-      }
-
-      const sensitiveFields = [
-        'username',
-        'user',
-        'user_id',
-        'password',
-        'email',
-        'phone',
-      ];
-
-      // Create a new object to store masked data
-      const maskedData = { ...parsedData };
-
-      // Mask sensitive fields
-      sensitiveFields.forEach((field) => {
-        if (field in maskedData) {
-          maskedData[field] = '********'; // Replace value with masked string
-        }
-      });
-
-      return maskedData; // Return the new object with masked fields
-    } else if (typeof data === 'object') {
-      // If data is already an object, handle masking directly
-      const sensitiveFields = [
-        'username',
-        'user',
-        'user_id',
-        'password',
-        'email',
-        'phone',
-      ];
-
-      const maskedData = { ...(data as Record<string, any>) };
-
-      // Mask sensitive fields
-      sensitiveFields.forEach((field) => {
-        if (field in maskedData) {
-          maskedData[field] = '********'; // Replace value with masked string
-        }
-      });
-
-      return maskedData; // Return the new object with masked fields
-    }
-
-    return data;
-  }
-
   // Function to track page hits
   private trackPageHit() {
     if (window.__nightmare || window.navigator.webdriver || window.Cypress)
@@ -278,6 +211,7 @@ export class FormoAnalytics implements IFormoAnalytics {
       const params = new URLSearchParams(url.search);
       this.trackEvent(Event.PAGE, {
         'user-agent': window.navigator.userAgent,
+        address: this.currentConnectedAddress,
         locale: language,
         location: location,
         referrer: document.referrer,
@@ -297,7 +231,7 @@ export class FormoAnalytics implements IFormoAnalytics {
     }
 
     this.currentChainId = undefined;
-    this.currentConnectedAccount = undefined;
+    this.currentConnectedAddress = undefined;
 
     if (this._provider) {
       const eventNames = Object.keys(this._registeredProviderListeners);
@@ -313,10 +247,63 @@ export class FormoAnalytics implements IFormoAnalytics {
     this._provider = provider;
 
     this.getCurrentWallet();
-    this.registerAccountsChangedListener();
+    this.registerAddressChangedListener();
     this.registerChainChangedListener();
   }
 
+  private async getCurrentWallet() {
+    if (!this.provider) {
+      console.warn('FormoAnalytics::getCurrentWallet: the provider is not set');
+      return;
+    }
+    const sessionData = sessionStorage.getItem(this.walletAddressSessionKey);
+    if (!sessionData) {
+      return null;
+    }
+
+    const parsedData = JSON.parse(sessionData);
+    const sessionExpiry = 30 * 60 * 1000; // 30 minutes
+    const currentTime = Date.now();
+
+    if (currentTime - parsedData.timestamp > sessionExpiry) {
+      console.warn('Session expired. Ignoring wallet address.');
+      sessionStorage.removeItem(this.walletAddressSessionKey); // Clear expired session data
+      return '';
+    }
+
+    this.onAddressConnected(parsedData.address);
+    return parsedData.address || '';
+  }
+
+  private async getCurrentChainId(): Promise<string> {
+    if (!this.provider) {
+      console.error('FormoAnalytics::getCurrentChainId: provider not set');
+    }
+    const chainIdHex = await this.provider?.request<string>({
+      method: 'eth_chainId',
+    });
+    // Because we're connected, the chainId cannot be null
+    if (!chainIdHex) {
+      console.error(
+        `FormoAnalytics::getCurrentChainId: chainIdHex is: ${chainIdHex}`
+      );
+    }
+
+    return parseInt(chainIdHex as string, 16).toString();
+  }
+
+  private registerAddressChangedListener() {
+    const listener = (...args: unknown[]) =>
+      this.onAddressChanged(args[0] as string[]);
+
+    this._provider?.on('accountsChanged', listener);
+    this._registeredProviderListeners['accountsChanged'] = listener;
+
+    const onAddressDisconnected = this.onAddressDisconnected.bind(this);
+    this._provider?.on('disconnect', onAddressDisconnected);
+    this._registeredProviderListeners['disconnect'] = onAddressDisconnected;
+  }
+
   private registerChainChangedListener() {
     const listener = (...args: unknown[]) =>
       this.onChainChanged(args[0] as string);
@@ -324,25 +311,50 @@ export class FormoAnalytics implements IFormoAnalytics {
     this._registeredProviderListeners['chainChanged'] = listener;
   }
 
-  private handleAccountDisconnected() {
-    if (!this.currentConnectedAccount) {
+  private async onAddressChanged(addresses: string[]) {
+    if (addresses.length > 0) {
+      const newAccount = addresses[0];
+      if (newAccount !== this.currentConnectedAddress) {
+        this.onAddressConnected(newAccount);
+      }
+    } else {
+      this.onAddressDisconnected();
+    }
+  }
+
+  private async onAddressConnected(address: string) {
+    if (address === this.currentConnectedAddress) {
+      // We have already reported this address
       return;
+    } else {
+      this.currentConnectedAddress = address;
     }
 
-    const disconnectAttributes = {
-      address: this.currentConnectedAccount,
-      chainId: this.currentChainId,
+    this.currentChainId = await this.getCurrentChainId();
+
+    this.connect({ chainId: this.currentChainId, address });
+    this.storeWalletAddress(address);
+  }
+
+  private onAddressDisconnected() {
+    if (!this.currentConnectedAddress) {
+      return;
+    }
+
+    const payload = {
+      chain_id: this.currentChainId,
+      address: this.currentConnectedAddress,
     };
     this.currentChainId = undefined;
-    this.currentConnectedAccount = undefined;
+    this.currentConnectedAddress = undefined;
     this.clearWalletAddress();
 
-    return this.trackEvent(Event.DISCONNECT, disconnectAttributes);
+    return this.trackEvent(Event.DISCONNECT, payload);
   }
 
   private async onChainChanged(chainIdHex: string) {
     this.currentChainId = parseInt(chainIdHex).toString();
-    if (!this.currentConnectedAccount) {
+    if (!this.currentConnectedAddress) {
       if (!this.provider) {
         console.error(
           'error',
@@ -363,7 +375,7 @@ export class FormoAnalytics implements IFormoAnalytics {
           return;
         }
 
-        this.currentConnectedAccount = res[0];
+        this.currentConnectedAddress = res[0];
       } catch (err) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if ((err as any).code !== 4001) {
@@ -380,88 +392,8 @@ export class FormoAnalytics implements IFormoAnalytics {
 
     return this.chain({
       chainId: this.currentChainId,
-      account: this.currentConnectedAccount,
-    });
-  }
-
-  private async onAccountsChanged(accounts: string[]) {
-    if (accounts.length > 0) {
-      const newAccount = accounts[0];
-      if (newAccount !== this.currentConnectedAccount) {
-        this.handleAccountConnected(newAccount);
-      }
-    } else {
-      this.handleAccountDisconnected();
-    }
-  }
-
-  private registerAccountsChangedListener() {
-    const listener = (...args: unknown[]) =>
-      this.onAccountsChanged(args[0] as string[]);
-
-    this._provider?.on('accountsChanged', listener);
-    this._registeredProviderListeners['accountsChanged'] = listener;
-
-    const handleAccountDisconnected = this.handleAccountDisconnected.bind(this);
-    this._provider?.on('disconnect', handleAccountDisconnected);
-    this._registeredProviderListeners['disconnect'] = handleAccountDisconnected;
-  }
-
-  private async getCurrentChainId(): Promise<string> {
-    if (!this.provider) {
-      console.error('FormoAnalytics::getCurrentChainId: provider not set');
-    }
-
-    const chainIdHex = await this.provider?.request<string>({
-      method: 'eth_chainId',
+      address: this.currentConnectedAddress,
     });
-    // Because we're connected, the chainId cannot be null
-    if (!chainIdHex) {
-      console.error(
-        `FormoAnalytics::getCurrentChainId: chainIdHex is: ${chainIdHex}`
-      );
-    }
-
-    return parseInt(chainIdHex as string, 16).toString();
-  }
-
-  private async handleAccountConnected(account: string) {
-    if (account === this.currentConnectedAccount) {
-      // We have already reported this account
-      return;
-    } else {
-      this.currentConnectedAccount = account;
-    }
-
-    this.currentChainId = await this.getCurrentChainId();
-
-    this.connect({ account, chainId: this.currentChainId });
-    this.storeWalletAddress(account);
-  }
-
-  private async getCurrentWallet() {
-    if (!this.provider) {
-      console.warn('FormoAnalytics::getCurrentWallet: the provider is not set');
-      return;
-    }
-    const sessionData = sessionStorage.getItem(this.sessionKey);
-
-    if (!sessionData) {
-      return null;
-    }
-
-    const parsedData = JSON.parse(sessionData);
-    const sessionExpiry = 30 * 60 * 1000; // 30 minutes
-    const currentTime = Date.now();
-
-    if (currentTime - parsedData.timestamp > sessionExpiry) {
-      console.warn('Session expired. Ignoring wallet address.');
-      sessionStorage.removeItem(this.sessionKey); // Clear expired session data
-      return '';
-    }
-
-    this.handleAccountConnected(parsedData.address);
-    return parsedData.address || '';
   }
 
   /**
@@ -479,82 +411,68 @@ export class FormoAnalytics implements IFormoAnalytics {
       timestamp: Date.now(),
     };
 
-    sessionStorage.setItem(this.sessionKey, JSON.stringify(sessionData));
+    sessionStorage.setItem(
+      this.walletAddressSessionKey,
+      JSON.stringify(sessionData)
+    );
   }
 
   /**
    * Clears the wallet address from session storage when disconnected.
    */
   private clearWalletAddress(): void {
-    sessionStorage.removeItem(this.sessionKey);
+    sessionStorage.removeItem(this.walletAddressSessionKey);
   }
 
-  // Function to build the API URL
-  private buildApiUrl(): string {
-    const { host, proxy, token, dataSource = 'analytics_events' } = this.config;
-    if (token) {
-      if (proxy) {
-        return `${proxy}/api/tracking`;
-      }
-      if (host) {
-        return `${host.replace(
-          /\/+$/,
-          ''
-        )}/v0/events?name=${dataSource}&token=${token}`;
-      }
-      return `${EVENTS_API}?name=${dataSource}&token=${token}`;
-    }
-    return 'Error: No token provided';
+  init(apiKey: string, options: Options): Promise<FormoAnalytics> {
+    const instance = new FormoAnalytics(apiKey, options);
+    return Promise.resolve(instance);
   }
 
-  connect({ account, chainId }: { account: string; chainId: ChainID }) {
+  connect({ chainId, address }: { chainId: ChainID; address: string }) {
     if (!chainId) {
-      throw new Error('FormoAnalytics::connect: chainId cannot be empty');
+      throw new Error('FormoAnalytics::connect: chain ID cannot be empty');
     }
-    if (!account) {
-      throw new Error('FormoAnalytics::connect: account cannot be empty');
+    if (!address) {
+      throw new Error('FormoAnalytics::connect: address cannot be empty');
     }
 
     this.currentChainId = chainId.toString();
-    this.currentConnectedAccount = account;
+    this.currentConnectedAddress = address;
 
     return this.trackEvent(Event.CONNECT, {
-      chainId,
-      address: account,
+      chain_id: chainId,
+      address: address,
     });
   }
 
-  disconnect(attributes?: { account?: string; chainId?: ChainID }) {
-    const account = attributes?.account || this.currentConnectedAccount;
-    if (!account) {
+  disconnect(params?: { chainId?: ChainID; address?: string }) {
+    const address = params?.address || this.currentConnectedAddress;
+    if (!address) {
       // We have most likely already reported this disconnection with the automatic
       // `disconnect` detection
       return;
     }
 
-    const chainId = attributes?.chainId || this.currentChainId;
-    const eventAttributes = {
-      account,
-      ...(chainId && { chainId }),
+    const payload = {
+      chain_id: params?.chainId || this.currentChainId,
+      address,
     };
-
     this.currentChainId = undefined;
-    this.currentConnectedAccount = undefined;
+    this.currentConnectedAddress = undefined;
 
-    return this.trackEvent(Event.DISCONNECT, eventAttributes);
+    return this.trackEvent(Event.DISCONNECT, payload);
   }
 
-  chain({ chainId, account }: { chainId: ChainID; account?: string }) {
+  chain({ chainId, address }: { chainId: ChainID; address?: string }) {
     if (!chainId || Number(chainId) === 0) {
       throw new Error('FormoAnalytics::chain: chainId cannot be empty or 0');
     }
-
-    if (!account && !this.currentConnectedAccount) {
+    if (!address && !this.currentConnectedAddress) {
       throw new Error(
-        'FormoAnalytics::chain: account was empty and no previous account has been recorded. You can either pass an account or call connect() first'
+        'FormoAnalytics::chain: address was empty and no previous address has been recorded. You can either pass an address or call connect() first'
       );
     }
-
     if (isNaN(Number(chainId))) {
       throw new Error(
         'FormoAnalytics::chain: chainId must be a valid hex or decimal number'
@@ -564,21 +482,11 @@ export class FormoAnalytics implements IFormoAnalytics {
     this.currentChainId = chainId.toString();
 
     return this.trackEvent(Event.CHAIN_CHANGED, {
-      chainId,
-      account: account || this.currentConnectedAccount,
+      chain_id: chainId,
+      address: address || this.currentConnectedAddress,
     });
   }
 
-  init(apiKey: string, projectId: string): Promise<FormoAnalytics> {
-    const instance = new FormoAnalytics(apiKey, projectId);
-
-    return Promise.resolve(instance);
-  }
-
-  identify(userData: any) {
-    this.identifyUser(userData);
-  }
-
   page() {
     this.trackPageHit();
   }

package/src/FormoAnalyticsProvider.tsx

@@ -18,7 +18,7 @@ export const FormoAnalyticsContext = createContext<FormoAnalytics | undefined>(
 
 export const FormoAnalyticsProvider = ({
   apiKey,
-  projectId,
+  options,
   disabled,
   children,
 }: FormoAnalyticsProviderProps) => {
@@ -32,15 +32,12 @@ export const FormoAnalyticsProvider = ({
         console.error('FormoAnalyticsProvider: No API key provided');
         return;
       }
-
       if (disabled) {
         console.warn('FormoAnalytics is disabled');
         return;
       }
-
       if (initializedStartedRef.current) return;
       initializedStartedRef.current = true;
-
       // Initialize Highlight.run if project ID is available
       if (HIGHLIGHT_PROJECT_ID) {
         try {
@@ -64,7 +61,7 @@ export const FormoAnalyticsProvider = ({
 
       // Initialize FormoAnalytics
       try {
-        const sdkInstance = await FormoAnalytics.init(apiKey, projectId);
+        const sdkInstance = await FormoAnalytics.init(apiKey, options);
         setSdk(sdkInstance);
         console.log('FormoAnalytics SDK initialized successfully');
       } catch (error) {
@@ -75,7 +72,7 @@ export const FormoAnalyticsProvider = ({
     };
 
     initialize();
-  }, [apiKey, disabled, projectId]);
+  }, [apiKey, disabled, options]);
 
   if (!isInitialized) {
     // Optionally show a loading state until initialization attempt finishes

package/src/constants/config.ts

@@ -1,4 +1,4 @@
-export const EVENTS_API = 'https://api.eu-central-1.aws.tinybird.co/v0/events';
+export const EVENTS_API_URL = 'https://events.formo.so/events';
 export const SESSION_STORAGE_ID_KEY = 'formo-analytics-session-id';
 export const COUNTRY_LIST = {
   // Africa

package/src/types/base.ts

@@ -1,8 +1,14 @@
+import { EIP1193Provider } from "./wallet";
+
 export type ChainID = string | number
 
+export interface Options {
+  provider?: EIP1193Provider;
+}
+
 export interface FormoAnalyticsProviderProps {
   apiKey: string;
-  projectId: string;
+  options: Options;
   disabled?: boolean;
   children: React.ReactNode;
 }