@formo/analytics 1.16.9 → 1.16.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formo/analytics",
-  "version": "1.16.9",
+  "version": "1.16.11",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/getformo/sdk.git"
@@ -87,7 +87,7 @@
   "size-limit": [
     {
       "path": "dist/index.umd.min.js",
-      "limit": "26 KB"
+      "limit": "27 KB"
     }
   ],
   "peerDependencies": {

package/src/FormoAnalytics.ts

@@ -9,15 +9,12 @@ import {
   TEventType,
 } from "./constants";
 import {
+  cookie,
   EventManager,
   EventQueue,
   IEventManager,
-  IStorageKeyManager,
-  local,
   logger,
   Logger,
-  session,
-  StorageKey,
 } from "./lib";
 import {
   Address,
@@ -40,7 +37,6 @@ export class FormoAnalytics implements IFormoAnalytics {
   private _providerListeners: Record<string, (...args: unknown[]) => void> = {};
   private session: FormoAnalyticsSession;
   private eventManager: IEventManager;
-  private storageKeyManager: IStorageKeyManager;
   private _providers: readonly EIP6963ProviderDetail[] = [];
 
   config: Config;
@@ -57,13 +53,9 @@ export class FormoAnalytics implements IFormoAnalytics {
       trackLocalhost: options.trackLocalhost || false,
     };
 
-    this.storageKeyManager = new StorageKey(this.config.writeKey);
-
-    this.session = new FormoAnalyticsSession(this.storageKeyManager);
+    this.session = new FormoAnalyticsSession();
     this.currentUserId =
-      (session.get(
-        this.storageKeyManager.getKey(SESSION_USER_ID_KEY)
-      ) as string) || undefined;
+      (cookie().get(SESSION_USER_ID_KEY) as string) || undefined;
 
     this.identify = this.identify.bind(this);
     this.connect = this.connect.bind(this);
@@ -87,8 +79,7 @@ export class FormoAnalytics implements IFormoAnalytics {
         retryCount: options.retryCount,
         maxQueueSize: options.maxQueueSize,
         flushInterval: options.flushInterval,
-      }),
-      this.storageKeyManager
+      })
     );
 
     // TODO: replace with eip6963
@@ -141,8 +132,8 @@ export class FormoAnalytics implements IFormoAnalytics {
    */
   public reset(): void {
     this.currentUserId = undefined;
-    local.remove(this.storageKeyManager.getKey(LOCAL_ANONYMOUS_ID_KEY));
-    session.remove(this.storageKeyManager.getKey(SESSION_USER_ID_KEY));
+    cookie().remove(LOCAL_ANONYMOUS_ID_KEY);
+    cookie().remove(SESSION_USER_ID_KEY);
   }
 
   /**
@@ -391,7 +382,8 @@ export class FormoAnalytics implements IFormoAnalytics {
     callback?: (...args: unknown[]) => void
   ): Promise<void> {
     try {
-      if (!params) { // If no params provided, auto-identify
+      if (!params) {
+        // If no params provided, auto-identify
         for (const providerDetail of this._providers) {
           const provider = providerDetail.provider;
           if (!provider) continue;
@@ -400,14 +392,22 @@ export class FormoAnalytics implements IFormoAnalytics {
             const address = await this.getAddress(provider);
             if (address) {
               // NOTE: do not set this.currentAddress without explicit connect or identify
-              await this.identify({
-                address,
-                providerName: providerDetail.info.name,
-                rdns: providerDetail.info.rdns,
-              }, properties, context, callback);
+              await this.identify(
+                {
+                  address,
+                  providerName: providerDetail.info.name,
+                  rdns: providerDetail.info.rdns,
+                },
+                properties,
+                context,
+                callback
+              );
             }
           } catch (err) {
-            logger.error(`Failed to identify provider ${providerDetail.info.name}:`, err);
+            logger.error(
+              `Failed to identify provider ${providerDetail.info.name}:`,
+              err
+            );
           }
         }
         return;
@@ -418,7 +418,7 @@ export class FormoAnalytics implements IFormoAnalytics {
       if (address) this.currentAddress = address;
       if (userId) {
         this.currentUserId = userId;
-        session.set(this.storageKeyManager.getKey(SESSION_USER_ID_KEY), userId);
+        cookie().set(SESSION_USER_ID_KEY, userId);
       }
 
       await this.trackEvent(
@@ -486,7 +486,7 @@ export class FormoAnalytics implements IFormoAnalytics {
    * @returns {Promise<void>}
    */
   async track(
-    event: EventType,
+    event: string,
     properties?: IFormoEventProperties,
     context?: IFormoEventContext,
     callback?: (...args: unknown[]) => void
@@ -701,7 +701,7 @@ export class FormoAnalytics implements IFormoAnalytics {
     };
     this.currentChainId = undefined;
     this.currentAddress = undefined;
-    session.remove(this.storageKeyManager.getKey(SESSION_USER_ID_KEY));
+    cookie().remove(SESSION_USER_ID_KEY);
 
     await this.trackEvent(
       EventType.DISCONNECT,
@@ -750,14 +750,8 @@ export class FormoAnalytics implements IFormoAnalytics {
   }
 
   private async trackFirstPageHit(): Promise<void> {
-    if (
-      session.get(this.storageKeyManager.getKey(SESSION_CURRENT_URL_KEY)) ===
-      null
-    ) {
-      session.set(
-        this.storageKeyManager.getKey(SESSION_CURRENT_URL_KEY),
-        window.location.href
-      );
+    if (cookie().get(SESSION_CURRENT_URL_KEY) === null) {
+      cookie().set(SESSION_CURRENT_URL_KEY, window.location.href);
     }
 
     return this.trackPageHit();
@@ -783,15 +777,10 @@ export class FormoAnalytics implements IFormoAnalytics {
   }
 
   private async onLocationChange(): Promise<void> {
-    const currentUrl = session.get(
-      this.storageKeyManager.getKey(SESSION_CURRENT_URL_KEY)
-    );
+    const currentUrl = cookie().get(SESSION_CURRENT_URL_KEY);
 
     if (currentUrl !== window.location.href) {
-      session.set(
-        this.storageKeyManager.getKey(SESSION_CURRENT_URL_KEY),
-        window.location.href
-      );
+      cookie().set(SESSION_CURRENT_URL_KEY, window.location.href);
       this.trackPageHit();
     }
   }
@@ -891,7 +880,9 @@ export class FormoAnalytics implements IFormoAnalytics {
     return this._provider;
   }
 
-  private async getAddress(provider?: EIP1193Provider): Promise<Address | null> {
+  private async getAddress(
+    provider?: EIP1193Provider
+  ): Promise<Address | null> {
     if (this.currentAddress) return this.currentAddress;
     const p = provider || this.provider;
     if (!p) {
@@ -1010,28 +1001,18 @@ interface IFormoAnalyticsSession {
 }
 
 class FormoAnalyticsSession implements IFormoAnalyticsSession {
-  private storageKeyManager: IStorageKeyManager;
-  constructor(storageKeyManager: IStorageKeyManager) {
-    this.storageKeyManager = storageKeyManager;
-  }
-
   public isWalletDetected(rdns: string): boolean {
-    const rdnses =
-      (session.get(
-        this.storageKeyManager.getKey(SESSION_WALLET_DETECTED_KEY)
-      ) as string[]) || [];
+    const rdnses = cookie().get(SESSION_WALLET_DETECTED_KEY)?.split(",") || [];
     return rdnses.includes(rdns);
   }
 
   public markWalletDetected(rdns: string): void {
-    const rdnses =
-      (session.get(
-        this.storageKeyManager.getKey(SESSION_WALLET_DETECTED_KEY)
-      ) as string[]) || [];
+    const rdnses = cookie().get(SESSION_WALLET_DETECTED_KEY)?.split(",") || [];
     rdnses.push(rdns);
-    session.set(
-      this.storageKeyManager.getKey(SESSION_WALLET_DETECTED_KEY),
-      rdnses
-    );
+    cookie().set(SESSION_WALLET_DETECTED_KEY, rdnses.join(","), {
+      // by the end of the day
+      expires: new Date(Date.now() + 86400 * 1000).toUTCString(),
+      path: "/",
+    });
   }
 }

package/src/FormoAnalyticsProvider.tsx

@@ -1,6 +1,6 @@
 import { createContext, useContext, useEffect, useRef, useState } from "react";
 import { FormoAnalytics } from "./FormoAnalytics";
-import { logger } from "./lib";
+import { initStorageManager, logger } from "./lib";
 import { FormoAnalyticsProviderProps, IFormoAnalytics } from "./types";
 
 const defaultContext: IFormoAnalytics = {
@@ -43,6 +43,7 @@ const InitializedAnalytics = ({
 }: FormoAnalyticsProviderProps) => {
   const [sdk, setSdk] = useState<IFormoAnalytics>(defaultContext);
   const initializedStartedRef = useRef(false);
+  initStorageManager(writeKey);
 
   const initializeFormoAnalytics = async (writeKey: string, options: any) => {
     try {

package/src/lib/event/EventFactory.ts

@@ -25,18 +25,13 @@ import { getCurrentTimeFormatted } from "../../utils/timestamp";
 import { isUndefined } from "../../validators";
 import { logger } from "../logger";
 import mergeDeepRight from "../ramda/mergeDeepRight";
-import { IStorageKeyManager, local, session } from "../storage";
+import { cookie, session } from "../storage";
 import { version } from "../version";
 import { CHANNEL, VERSION } from "./constants";
 import { IEventFactory } from "./type";
 import { generateAnonymousId } from "./utils";
 
 class EventFactory implements IEventFactory {
-  private storageKeyManager: IStorageKeyManager;
-  constructor(storageKeyManager: IStorageKeyManager) {
-    this.storageKeyManager = storageKeyManager;
-  }
-
   private getTimezone(): string {
     try {
       return Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -103,9 +98,7 @@ class EventFactory implements IEventFactory {
       referrer: document.referrer,
     };
     const storedTrafficSources =
-      (session.get(
-        this.storageKeyManager.getKey(SESSION_TRAFFIC_SOURCE_KEY)
-      ) as ITrafficSource) || {};
+      (session().get(SESSION_TRAFFIC_SOURCE_KEY) as ITrafficSource) || {};
 
     const finalTrafficSources: ITrafficSource = {
       ref: contextTrafficSources.ref || storedTrafficSources?.ref || "",
@@ -144,10 +137,7 @@ class EventFactory implements IEventFactory {
     );
 
     if (Object.keys(sessionStoredTrafficSources).length)
-      session.set(
-        this.storageKeyManager.getKey(SESSION_TRAFFIC_SOURCE_KEY),
-        sessionStoredTrafficSources
-      );
+      session().set(SESSION_TRAFFIC_SOURCE_KEY, sessionStoredTrafficSources);
 
     return finalTrafficSources;
   };
@@ -220,11 +210,11 @@ class EventFactory implements IEventFactory {
       version: VERSION,
     } as Partial<IFormoEvent>;
 
-    if (!local.isAvailable()) {
+    if (!cookie().isAvailable()) {
       commonEventData.anonymous_id = generateNativeUUID();
     } else {
       commonEventData.anonymous_id = generateAnonymousId(
-        this.storageKeyManager.getKey(LOCAL_ANONYMOUS_ID_KEY)
+        LOCAL_ANONYMOUS_ID_KEY
       );
     }
 

package/src/lib/event/EventManager.ts

@@ -1,7 +1,6 @@
 import { Address, APIEvent } from "../../types";
 import { logger } from "../logger";
 import { IEventQueue } from "../queue";
-import { IStorageKeyManager } from "../storage";
 import { EventFactory } from "./EventFactory";
 import { IEventFactory, IEventManager } from "./type";
 
@@ -16,9 +15,9 @@ class EventManager implements IEventManager {
    *
    * @param eventQueue Event queue instance
    */
-  constructor(eventQueue: IEventQueue, storageKeyManager: IStorageKeyManager) {
+  constructor(eventQueue: IEventQueue) {
     this.eventQueue = eventQueue;
-    this.eventFactory = new EventFactory(storageKeyManager);
+    this.eventFactory = new EventFactory();
   }
 
   /**

package/src/lib/event/utils.ts

@@ -1,14 +1,33 @@
 import { AnonymousID } from "../../types";
 import { generateNativeUUID } from "../../utils";
-import { local } from "../storage";
+import { cookie } from "../storage";
 
 const generateAnonymousId = (key: string): AnonymousID => {
-  const storedAnonymousId = local.get(key);
+  const storedAnonymousId = cookie().get(key);
   if (storedAnonymousId && typeof storedAnonymousId === "string")
     return storedAnonymousId as AnonymousID;
   const newAnonymousId = generateNativeUUID();
-  local.set(key, newAnonymousId);
+  cookie().set(key, newAnonymousId, {
+    maxAge: Date.now() + 1000 * 60 * 60 * 24 * 365, // 1 year
+    domain: getCookieDomain(),
+    path: "/",
+  });
   return newAnonymousId;
 };
 
-export { generateAnonymousId };
+function getCookieDomain(hostname: string = window.location.hostname): string {
+  // Special cases
+  if (hostname === "localhost" || /^\d{1,3}(\.\d{1,3}){3}$/.test(hostname)) {
+    // Localhost or IP address
+    return "";
+  }
+
+  const parts = hostname.split(".");
+  if (parts.length >= 2) {
+    return `.${parts.slice(-2).join(".")}`; // e.g. example.com
+  }
+
+  return "";
+}
+
+export { generateAnonymousId, getCookieDomain };

package/src/lib/storage/StorageManager.ts

@@ -0,0 +1,51 @@
+import { logger } from "../logger";
+import CookieStorage from "./built-in/cookie";
+import MemoryStorage from "./built-in/memory";
+import WebStorage from "./built-in/web";
+import { IStorage, StorageType } from "./type";
+
+// Fallback as follows: cookieStorage, localStorage, sessionStorage, memoryStorage
+const TYPES: StorageType[] = [
+  "cookieStorage",
+  "localStorage",
+  "sessionStorage",
+  "memoryStorage",
+];
+
+export class StorageManager {
+  private storages: Map<StorageType, IStorage> = new Map();
+
+  constructor(private readonly writeKey: string) {}
+
+  getStorage(type: StorageType): IStorage {
+    if (!this.storages.has(type)) {
+      let storage = this.createStorage(type);
+      // If storage is not available, try next
+      while (!storage.isAvailable()) {
+        const index = TYPES.indexOf(type);
+        logger.warn(
+          `Storage ${type} is not available, trying ${TYPES[index + 1]}`
+        );
+        storage = this.createStorage(TYPES[index + 1]);
+      }
+
+      // Add to cache
+      this.storages.set(type, this.createStorage(type));
+    }
+    return this.storages.get(type)!;
+  }
+
+  private createStorage(type: StorageType): IStorage {
+    switch (type) {
+      case "cookieStorage":
+        return new CookieStorage(this.writeKey);
+      case "localStorage":
+        return new WebStorage(this.writeKey, localStorage);
+      case "sessionStorage":
+        return new WebStorage(this.writeKey, sessionStorage);
+      case "memoryStorage":
+      default:
+        return new MemoryStorage(this.writeKey);
+    }
+  }
+}

package/src/lib/storage/built-in/blueprint.ts

@@ -0,0 +1,17 @@
+import { KEY_PREFIX } from "../constant";
+import { CookieOptions } from "../type";
+
+abstract class StorageBlueprint {
+  constructor(private readonly writeKey: string) {}
+
+  abstract isAvailable(): boolean;
+  abstract set(key: string, value: string, options?: CookieOptions): void;
+  abstract get(key: string): any;
+  abstract remove(key: string): void;
+
+  protected getKey(key: string): string {
+    return `${KEY_PREFIX}_${this.writeKey}.${key}`;
+  }
+}
+
+export default StorageBlueprint;

package/src/lib/storage/built-in/cookie.ts

@@ -0,0 +1,66 @@
+import StorageBlueprint from "./blueprint";
+import { CookieOptions } from "../type";
+
+class CookieStorage extends StorageBlueprint {
+  public override isAvailable(): boolean {
+    try {
+      document.cookie = "cookie_test=1";
+      const available = document.cookie.includes("cookie_test=");
+      this.remove("cookie_test");
+      return available;
+    } catch {
+      return false;
+    }
+  }
+
+  public override set(
+    key: string,
+    value: string,
+    options?: CookieOptions
+  ): void {
+    const expires = options?.expires;
+    const maxAge = options?.maxAge;
+    const path = options?.path || "/";
+    const domain = options?.domain;
+    const sameSite = options?.sameSite;
+    const secure = options?.secure || false;
+
+    let cookie = `${encodeURIComponent(this.getKey(key))}=${encodeURIComponent(
+      value
+    )}`;
+    if (maxAge) {
+      cookie += "; max-age=" + maxAge;
+    }
+    if (expires) {
+      cookie += "; expires=" + expires;
+    }
+    if (path) {
+      cookie += "; path=" + path;
+    }
+    if (domain) {
+      cookie += "; domain=" + domain;
+    }
+    if (sameSite) {
+      cookie += "; samesite=" + sameSite;
+    }
+    if (secure) {
+      cookie += "; secure";
+    }
+    document.cookie = cookie;
+  }
+
+  public override get(key: string): string | null {
+    const match = document.cookie.match(
+      new RegExp(`(?:^|; )${encodeURIComponent(this.getKey(key))}=([^;]*)`)
+    );
+    return match ? decodeURIComponent(match[1]) : null;
+  }
+
+  public override remove(key: string): void {
+    document.cookie = `${encodeURIComponent(
+      this.getKey(key)
+    )}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+  }
+}
+
+export default CookieStorage;

package/src/lib/storage/built-in/memory.ts

@@ -0,0 +1,23 @@
+import StorageBlueprint from "./blueprint";
+
+class MemoryStorage extends StorageBlueprint {
+  private memoryStorage: Record<string, string> = {};
+
+  public override isAvailable(): boolean {
+    return true;
+  }
+
+  public override set(key: string, value: string): void {
+    this.memoryStorage[this.getKey(key)] = value;
+  }
+
+  public override get(key: string): string | null {
+    return this.memoryStorage[this.getKey(key)] || null;
+  }
+
+  public override remove(key: string): void {
+    delete this.memoryStorage[this.getKey(key)];
+  }
+}
+
+export default MemoryStorage;

package/src/lib/storage/built-in/web.ts

@@ -0,0 +1,57 @@
+import { logger } from "../../logger";
+import { JSON_PREFIX } from "../constant";
+import StorageBlueprint from "./blueprint";
+
+class WebStorage extends StorageBlueprint {
+  constructor(writeKey: string, private readonly backend: Storage) {
+    super(writeKey);
+  }
+
+  public override isAvailable(): boolean {
+    try {
+      const testKey = "__storage_test__";
+      this.backend.setItem(testKey, "1");
+      this.backend.removeItem(testKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  public override set(key: string, value: any): void {
+    if (typeof value === "boolean") value = value === true ? "true" : "false";
+    if (typeof value === "object") value = JSON_PREFIX + JSON.stringify(value);
+    this.backend.setItem(key, value);
+  }
+
+  public override get(key: string): string | boolean | Record<any, any> | null {
+    const value = this.backend.getItem(key);
+
+    if (!value || typeof value !== "string") return null;
+    if (["null", "undefined"].some((item) => item == value)) return null;
+
+    if (value.startsWith(JSON_PREFIX)) {
+      try {
+        return JSON.parse(value.slice(JSON_PREFIX.length));
+      } catch (error) {
+        logger.error(
+          `[FORMO_ERROR] ${this.backend.constructor.name} failed to parse JSON`,
+          error
+        );
+        return null;
+      }
+    }
+
+    if (["true", "false"].some((item) => item == value)) {
+      return JSON.parse(value);
+    }
+
+    return value;
+  }
+
+  public override remove(key: string): void {
+    this.backend.removeItem(key);
+  }
+}
+
+export default WebStorage;

package/src/lib/storage/constant.ts

@@ -0,0 +1,2 @@
+export const JSON_PREFIX = "__json=";
+export const KEY_PREFIX = "formo";

package/src/lib/storage/index.ts

@@ -1,4 +1,25 @@
-export { StorageKey } from "./key";
-export { default as local } from "./local";
-export { default as session } from "./session";
+import { IStorage, StorageType } from "./type";
+import { StorageManager } from "./StorageManager";
 export * from "./type";
+
+let globalManager: StorageManager | null = null;
+
+export function initStorageManager(writeKey: string): void {
+  if (!globalManager) {
+    globalManager = new StorageManager(writeKey);
+  }
+}
+
+function getStorageInstance(type: StorageType): IStorage {
+  if (!globalManager) {
+    throw new Error(
+      "StorageManager not initialized. Call initStorageManager(writeKey) first."
+    );
+  }
+  return globalManager.getStorage(type);
+}
+
+export const cookie = () => getStorageInstance("cookieStorage");
+export const local = () => getStorageInstance("localStorage");
+export const session = () => getStorageInstance("sessionStorage");
+export const memory = () => getStorageInstance("memoryStorage");

package/src/lib/storage/type.ts

@@ -1,3 +1,21 @@
-export interface IStorageKeyManager {
-  getKey(name: string): string;
+export type StorageType =
+  | "cookieStorage"
+  | "localStorage"
+  | "sessionStorage"
+  | "memoryStorage";
+
+export type CookieOptions = {
+  maxAge?: number;
+  expires?: string;
+  path?: string;
+  domain?: string;
+  secure?: boolean;
+  sameSite?: "lax" | "strict" | "none";
+};
+
+export interface IStorage {
+  isAvailable(): boolean;
+  set(key: string, value: string, options?: CookieOptions): void;
+  get(key: string): any;
+  remove(key: string): void;
 }

package/src/lib/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '1.16.9';
+export const version = '1.16.11';

package/test/lib/events.spec.ts

@@ -0,0 +1,12 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { getCookieDomain } from "../../src/lib/event/utils";
+
+describe("getCookieDomain", () => {
+  it("should return the cookie domain format", () => {
+    expect(getCookieDomain("192.168.0.1")).to.equal("");
+    expect(getCookieDomain("localhost:3000")).to.equal("");
+    expect(getCookieDomain("example.com")).to.equal(".example.com");
+    expect(getCookieDomain("www.example.com")).to.equal(".example.com");
+  });
+});

package/dist/cjs/src/lib/storage/key.d.ts

@@ -1,9 +0,0 @@
-import { IStorageKeyManager } from "./type";
-declare class StorageKey implements IStorageKeyManager {
-    private readonly prefix;
-    private readonly writeKey;
-    constructor(writeKey: string);
-    getKey(name: string): string;
-}
-export { StorageKey };
-//# sourceMappingURL=key.d.ts.map

package/dist/cjs/src/lib/storage/key.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../../../../src/lib/storage/key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAE5C,cAAM,UAAW,YAAW,kBAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,QAAQ,EAAE,MAAM;IAI5B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAG7B;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/cjs/src/lib/storage/key.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StorageKey = void 0;
-var StorageKey = /** @class */ (function () {
-    function StorageKey(writeKey) {
-        this.prefix = "formo";
-        this.writeKey = writeKey;
-    }
-    StorageKey.prototype.getKey = function (name) {
-        return this.prefix + "_" + this.writeKey + "." + name;
-    };
-    return StorageKey;
-}());
-exports.StorageKey = StorageKey;
-//# sourceMappingURL=key.js.map