@formo/analytics 1.16.4 → 1.16.6

package/src/lib/event/EventManager.ts

@@ -0,0 +1,39 @@
+import { Address, APIEvent } from "../../types";
+import { logger } from "../logger";
+import { IEventQueue } from "../queue";
+import { EventFactory } from "./EventFactory";
+import { IEventFactory, IEventManager } from "./type";
+
+/**
+ * A service to generate valid event payloads and queue them for processing
+ */
+class EventManager implements IEventManager {
+  eventQueue: IEventQueue;
+  eventFactory: IEventFactory;
+
+  /**
+   *
+   * @param eventQueue Event queue instance
+   */
+  constructor(eventQueue: IEventQueue) {
+    this.eventQueue = eventQueue;
+    this.eventFactory = new EventFactory();
+  }
+
+  /**
+   * Consumes a new incoming event
+   * @param event Incoming event data
+   */
+  addEvent(event: APIEvent, address?: Address, userId?: string): void {
+    const { callback, ..._event } = event;
+    const formoEvent = this.eventFactory.create(_event, address, userId);
+    this.eventQueue.enqueue(formoEvent, (err, _, data) => {
+      if (err) {
+        logger.error("Error sending events:", err);
+      } else logger.info(`Events sent successfully: ${data.length} events`);
+      callback?.(err, _, data);
+    });
+  }
+}
+
+export { EventManager };

package/src/lib/event/constants.ts

@@ -0,0 +1,4 @@
+const CHANNEL = "web";
+const VERSION = "0";
+
+export { CHANNEL, VERSION };

package/src/lib/event/index.ts

@@ -1,2 +1,3 @@
 export * from "./EventFactory";
+export * from "./EventManager";
 export * from "./type";

package/src/lib/event/type.ts

@@ -1,11 +1,9 @@
-import { UUID } from "crypto";
-import { APIEvent, IFormoEvent } from "../../types";
+import { Address, APIEvent, IFormoEvent } from "../../types";
+
+export interface IEventManager {
+  addEvent(event: APIEvent, address?: Address, userId?: string): void;
+}
 
 export interface IEventFactory {
-  create(
-    anonymous_id: UUID,
-    user_id: string | null,
-    address: string | null,
-    event: APIEvent
-  ): IFormoEvent;
+  create(event: APIEvent, address?: Address, userId?: string): IFormoEvent;
 }

package/src/lib/event/utils.ts

@@ -0,0 +1,15 @@
+import { LOCAL_ANONYMOUS_ID_KEY } from "../../constants";
+import { AnonymousID } from "../../types";
+import { generateNativeUUID } from "../../utils";
+import { local } from "../storage";
+
+const generateAnonymousId = (): AnonymousID => {
+  const storedAnonymousId = local.get(LOCAL_ANONYMOUS_ID_KEY);
+  if (storedAnonymousId && typeof storedAnonymousId === "string")
+    return storedAnonymousId as AnonymousID;
+  const newAnonymousId = generateNativeUUID();
+  local.set(LOCAL_ANONYMOUS_ID_KEY, newAnonymousId);
+  return newAnonymousId;
+};
+
+export { generateAnonymousId };

package/src/lib/queue/EventQueue.ts

@@ -18,6 +18,10 @@ type QueueItem = {
   callback: (...args: any) => any;
 };
 
+type IFormoEventFlushPayload = IFormoEventPayload & {
+  sent_at: string;
+};
+
 type Options = {
   url: string;
   flushAt?: number;
@@ -97,17 +101,19 @@ export class EventQueue implements IEventQueue {
   }
 
   //#region Public functions
+  private async generateMessageId(event: IFormoEvent): Promise<string> {
+    const formattedTimestamp = toDateHourMinute(new Date(event.original_timestamp));
+    const eventForHashing = { ...event, original_timestamp: formattedTimestamp };
+    const eventString = JSON.stringify(eventForHashing);
+    return hash(eventString);
+  }
+
   async enqueue(event: IFormoEvent, callback?: (...args: any) => void) {
     callback = callback || noop;
 
-    const formattedTimestamp = toDateHourMinute(new Date(event.timestamp));
-    const originTimestamp = event.timestamp;
-    event.timestamp = formattedTimestamp;
-
-    const eventString = JSON.stringify(event);
-    const eventId = await hash(eventString);
+    const message_id = await this.generateMessageId(event);
     // check if the message already exists
-    if (await this.isDuplicate(eventId)) {
+    if (await this.isDuplicate(message_id)) {
       logger.warn(
         `Event already enqueued, try again after ${millisecondsToSecond(
           this.flushIntervalMs
@@ -117,12 +123,12 @@ export class EventQueue implements IEventQueue {
     }
 
     this.queue.push({
-      message: { ...event, timestamp: originTimestamp, id: eventId },
+      message: { ...event, message_id },
       callback,
     });
 
     logger.log(
-      `Event enqueued: ${getActionDescriptor(event.action, event.payload)}`
+      `Event enqueued: ${getActionDescriptor(event.type, event.properties)}`
     );
 
     if (!this.flushed) {
@@ -170,7 +176,13 @@ export class EventQueue implements IEventQueue {
 
     const items = this.queue.splice(0, this.flushAt);
     this.payloadHashes.clear();
-    const data = items.map((item) => item.message);
+    
+    // Generate sent_at once for the entire batch
+    const sentAt = new Date().toISOString();
+    const data: IFormoEventFlushPayload[] = items.map((item) => ({
+      ...item.message,
+      sent_at: sentAt
+    }));
 
     const done = (err?: Error) => {
       items.forEach(({ message, callback }) => callback(err, message, data));

package/src/lib/ramda/internal/_curry1.ts

@@ -0,0 +1,19 @@
+import _isPlaceholder from "./_isPlaceholder";
+
+/**
+ * Optimized internal one-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+export default function _curry1(fn: Function) {
+  return function f1(a: any) {
+    if (arguments.length === 0 || _isPlaceholder(a)) {
+      return f1;
+    } else {
+      return fn.apply(this, arguments);
+    }
+  };
+}

package/src/lib/ramda/internal/_curry2.ts

@@ -0,0 +1,37 @@
+import _curry1 from "./_curry1";
+import _isPlaceholder from "./_isPlaceholder";
+
+/**
+ * Optimized internal two-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+export default function _curry2(fn: Function) {
+  return function f2(a: any, b: any) {
+    switch (arguments.length) {
+      case 0:
+        return f2;
+      case 1:
+        return _isPlaceholder(a)
+          ? f2
+          : _curry1(function (_b: any) {
+              return fn(a, _b);
+            });
+      default:
+        return _isPlaceholder(a) && _isPlaceholder(b)
+          ? f2
+          : _isPlaceholder(a)
+          ? _curry1(function (_a: any) {
+              return fn(_a, b);
+            })
+          : _isPlaceholder(b)
+          ? _curry1(function (_b: any) {
+              return fn(a, _b);
+            })
+          : fn(a, b);
+    }
+  };
+}

package/src/lib/ramda/internal/_curry3.ts

@@ -0,0 +1,68 @@
+import _curry1 from "./_curry1";
+import _curry2 from "./_curry2";
+import _isPlaceholder from "./_isPlaceholder";
+
+/**
+ * Optimized internal three-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+export default function _curry3(fn: Function) {
+  return function f3(a: any, b: any, c: any) {
+    switch (arguments.length) {
+      case 0:
+        return f3;
+      case 1:
+        return _isPlaceholder(a)
+          ? f3
+          : _curry2(function (_b: any, _c: any) {
+              return fn(a, _b, _c);
+            });
+      case 2:
+        return _isPlaceholder(a) && _isPlaceholder(b)
+          ? f3
+          : _isPlaceholder(a)
+          ? _curry2(function (_a: any, _c: any) {
+              return fn(_a, b, _c);
+            })
+          : _isPlaceholder(b)
+          ? _curry2(function (_b: any, _c: any) {
+              return fn(a, _b, _c);
+            })
+          : _curry1(function (_c: any) {
+              return fn(a, b, _c);
+            });
+      default:
+        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c)
+          ? f3
+          : _isPlaceholder(a) && _isPlaceholder(b)
+          ? _curry2(function (_a: any, _b: any) {
+              return fn(_a, _b, c);
+            })
+          : _isPlaceholder(a) && _isPlaceholder(c)
+          ? _curry2(function (_a: any, _c: any) {
+              return fn(_a, b, _c);
+            })
+          : _isPlaceholder(b) && _isPlaceholder(c)
+          ? _curry2(function (_b: any, _c: any) {
+              return fn(a, _b, _c);
+            })
+          : _isPlaceholder(a)
+          ? _curry1(function (_a: any) {
+              return fn(_a, b, c);
+            })
+          : _isPlaceholder(b)
+          ? _curry1(function (_b: any) {
+              return fn(a, _b, c);
+            })
+          : _isPlaceholder(c)
+          ? _curry1(function (_c: any) {
+              return fn(a, b, _c);
+            })
+          : fn(a, b, c);
+    }
+  };
+}

package/src/lib/ramda/internal/_has.ts

@@ -0,0 +1,3 @@
+export default function _has(prop: any, obj: any) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}

package/src/lib/ramda/internal/_isObject.ts

@@ -0,0 +1,3 @@
+export default function _isObject(x: any) {
+  return Object.prototype.toString.call(x) === "[object Object]";
+}

package/src/lib/ramda/internal/_isPlaceholder.ts

@@ -0,0 +1,5 @@
+export default function _isPlaceholder(a: any) {
+  return (
+    a != null && typeof a === "object" && a["@@functional/placeholder"] === true
+  );
+}

package/src/lib/ramda/mergeDeepRight.ts

@@ -0,0 +1,13 @@
+import _curry2 from "./internal/_curry2";
+import mergeDeepWithKey from "./mergeDeepWithKey";
+
+const mergeDeepRight = _curry2(function mergeDeepRight(lObj: any, rObj: any) {
+  return mergeDeepWithKey(
+    function (_: Function, __: any, rVal: any) {
+      return rVal;
+    },
+    lObj,
+    rObj
+  );
+});
+export default mergeDeepRight;

package/src/lib/ramda/mergeDeepWithKey.ts

@@ -0,0 +1,22 @@
+import _curry3 from "./internal/_curry3";
+import _isObject from "./internal/_isObject";
+import mergeWithKey from "./mergeWithKey";
+
+const mergeDeepWithKey = _curry3(function mergeDeepWithKey(
+  fn: Function,
+  lObj: any,
+  rObj: any
+) {
+  return mergeWithKey(
+    function (k: Function, lVal: any, rVal: any) {
+      if (_isObject(lVal) && _isObject(rVal)) {
+        return mergeDeepWithKey(fn, lVal, rVal);
+      } else {
+        return fn(k, lVal, rVal);
+      }
+    },
+    lObj,
+    rObj
+  );
+});
+export default mergeDeepWithKey;

package/src/lib/ramda/mergeWithKey.ts

@@ -0,0 +1,28 @@
+import _curry3 from "./internal/_curry3";
+import _has from "./internal/_has";
+
+const mergeWithKey = _curry3(function mergeWithKey(
+  fn: Function,
+  l: any,
+  r: any
+) {
+  const result: any = {};
+  let k;
+  l = l || {};
+  r = r || {};
+
+  for (k in l) {
+    if (_has(k, l)) {
+      result[k] = _has(k, r) ? fn(k, l[k], r[k]) : l[k];
+    }
+  }
+
+  for (k in r) {
+    if (_has(k, r) && !_has(k, result)) {
+      result[k] = r[k];
+    }
+  }
+
+  return result;
+});
+export default mergeWithKey;

package/src/lib/storage/native.ts

@@ -41,6 +41,10 @@ export class NativeStorage {
     }
   }
 
+  public isAvailable(): boolean {
+    return this.isBrowser;
+  }
+
   public set(key: string, value: any): void {
     if (typeof value === "boolean") value = value === true ? "true" : "false";
     if (typeof value === "object")

package/src/lib/version.ts

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

package/src/types/base.ts

@@ -1,6 +1,7 @@
 import { LogLevel } from "../lib";
 import { EIP1193Provider } from "./provider";
 
+export type Nullable<T> = T | null;
 // Decimal chain ID
 export type ChainID = number;
 

package/src/types/events.ts

@@ -1,69 +1,104 @@
 import { UUID } from "crypto";
-import { Address, ChainID } from "./base";
+import { Address, ChainID, Nullable } from "./base";
+import { TEventChannel, TEventType } from "../constants";
 
-export interface IFormoEvent {
-  anonymous_id: UUID;
-  user_id: string | null;
-  action: string;
-  payload: Record<string, unknown>;
-  address: string | null;
-  timestamp: string;
+export type AnonymousID = UUID;
+
+export interface ICommonProperties {
+  anonymous_id: AnonymousID;
+  user_id: Nullable<string>;
+  address: Nullable<string>;
+  type: TEventType;
+  channel: TEventChannel;
   version: string;
+  original_timestamp: string;
+  event?: Nullable<string>;
+}
+
+export type IFormoEventProperties = Record<string, unknown>;
+export type IFormoEventContext = Record<string, unknown>;
+export type UTMParameters = Record<string, string>;
+
+export interface IFormoEvent extends ICommonProperties {
+  context: Nullable<IFormoEventContext>;
+  properties: Nullable<IFormoEventProperties>;
 }
 
 export type IFormoEventPayload = IFormoEvent & {
-  id: string;
+  message_id: string;
 };
 
-export type APIEvent =
-  | {
-      action: "page_hit";
-    }
-  | {
-      action: "detect_wallet";
-      providerName: string;
-      rdns: string;
-    }
-  | {
-      action: "identify";
-      address: string;
-      providerName: string;
-      rdns: string;
-      userId?: string;
-    }
-  | {
-      action: "chain_changed";
-      chainId: ChainID;
-      address: Address;
-    }
-  | {
-      action: "transaction";
-      status: TransactionStatus;
-      chainId: ChainID;
-      address: Address;
-      data: string;
-      to: string;
-      value: string;
-      transactionHash: string;
-    }
-  | {
-      action: "signature";
-      status: SignatureStatus;
-      chainId: ChainID;
-      address: Address;
-      message: string;
-      signatureHash: string;
-    }
-  | {
-      action: "disconnect";
-      chainId: ChainID;
-      address: Address;
-    }
-  | {
-      action: "connect";
-      chainId: ChainID;
-      address: Address;
-    };
+//#region Specific Event Types
+export interface PageAPIEvent {
+  type: "page";
+  name?: string;
+  category?: string;
+}
+export interface DetectAPIEvent {
+  type: "detect";
+  providerName: string;
+  rdns: string;
+}
+export interface IdentifyAPIEvent {
+  type: "identify";
+  address: string;
+  providerName: string;
+  rdns: string;
+  userId?: Nullable<string>;
+}
+export interface ChainAPIEvent {
+  type: "chain";
+  chainId: ChainID;
+  address: Address;
+}
+export interface TransactionAPIEvent {
+  type: "transaction";
+  status: TransactionStatus;
+  chainId: ChainID;
+  address: Address;
+  data: string;
+  to: string;
+  value: string;
+  transactionHash: string;
+}
+export interface SignatureAPIEvent {
+  type: "signature";
+  status: SignatureStatus;
+  chainId: ChainID;
+  address: Address;
+  message: string;
+  signatureHash: string;
+}
+export interface ConnectAPIEvent {
+  type: "connect";
+  chainId: ChainID;
+  address: Address;
+}
+export interface DisconnectAPIEvent {
+  type: "disconnect";
+  chainId: ChainID;
+  address: Address;
+}
+export interface TrackAPIEvent {
+  type: "track";
+  event: string;
+}
+
+export type APIEvent = {
+  properties?: IFormoEventProperties;
+  context?: IFormoEventContext;
+  callback?: (...args: unknown[]) => void;
+} & (
+  | PageAPIEvent
+  | DetectAPIEvent
+  | IdentifyAPIEvent
+  | ChainAPIEvent
+  | TransactionAPIEvent
+  | SignatureAPIEvent
+  | ConnectAPIEvent
+  | DisconnectAPIEvent
+  | TrackAPIEvent
+);
 
 export enum SignatureStatus {
   REQUESTED = "requested",

package/src/utils/base.ts

@@ -1,3 +1,3 @@
-export const getActionDescriptor = (action: string, payload: any): string => {
-  return `${action}${payload?.status ? ` ${payload?.status}` : ""}`;
+export const getActionDescriptor = (type: string, properties: any): string => {
+  return `${type}${properties?.status ? ` ${properties?.status}` : ""}`;
 };

package/src/utils/timestamp.ts

@@ -0,0 +1,9 @@
+const getFormattedTimestamp = (date: Date): string => date.toISOString();
+
+/**
+ * To get the current timestamp in ISO string format
+ * @returns ISO formatted timestamp string
+ */
+const getCurrentTimeFormatted = (): string => getFormattedTimestamp(new Date());
+
+export { getCurrentTimeFormatted, getFormattedTimestamp };