@reservamos/browser-analytics 0.1.3 → 0.1.4-alpha.10

package/src/events/viewResults/trackViewResults.ts

@@ -0,0 +1,14 @@
+import type { ViewResultsProps } from './viewResultsSchema';
+import { trackEvent } from '@/track';
+
+const EVENT_NAME = 'View Results';
+
+/**
+ * Tracks a View Results event.
+ * @param {ViewResultsProps} eventData - The data associated with the View Results event.
+ */
+function trackViewResults(eventData: ViewResultsProps) {
+  trackEvent(EVENT_NAME, eventData);
+}
+
+export default trackViewResults;

package/src/events/viewResults/viewResultsSchema.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import dateValidation from '@/util/dateValidation';
+import productValidation from '@/util/productValidation';
+
+const viewResultsSchema = z.object({
+  'Bus count': z.number().int('Bus count must be an integer'),
+  'Departure': z.string().refine(dateValidation, {
+    message: 'Invalid departure datetime format',
+  }),
+  'Departure Delta': z
+    .number()
+    .int('Departure Delta must be an integer')
+    .optional(),
+  'Destination': z.string().min(1, 'Destination is required').optional(),
+  'Destination Terminal': z
+    .string()
+    .min(1, 'Destination terminal is required')
+    .optional(),
+  'Has Frequent Buses': z.boolean().default(false).optional(),
+  'Origin': z.string().min(1, 'Origin is required'),
+  'Origin Terminal': z.string().min(1, 'Origin terminal is required'),
+  'Route': z.string().min(1, 'Route is required'),
+  'product': productValidation,
+});
+
+type ViewResultsProps = z.infer<typeof viewResultsSchema>;
+
+export type { ViewResultsProps };
+export default viewResultsSchema;

package/src/index.ts

@@ -1,12 +1,51 @@
-import { trackTest } from './events/trackTest';
-import { init } from './init';
+import type { InterestInHomeProps } from '@/events/interestInHome';
+import type { InterestInSearchProps } from '@/events/interestInSearch';
+import type { PassengersCreatedProps } from '@/events/passengersCreated';
+import type { PaymentAttemptProps } from '@/events/paymentAttempt';
+import type { PickedDepartureProps } from '@/events/pickedDeparture';
+import type { PurchaseAttemptProps } from '@/events/purchaseAttempt';
+import type { SearchProps } from '@/events/search';
+import type { SeatChangeProps } from '@/events/seatChange';
+import type { ViewResultsProps } from '@/events/viewResults';
+import identify from '@/events/identify';
+import trackInterestInHome from '@/events/interestInHome';
+import trackInterestInSearch from '@/events/interestInSearch';
+import trackPassengersCreated from '@/events/passengersCreated';
+import trackPaymentAttempt from '@/events/paymentAttempt';
+import trackPickedDeparture from '@/events/pickedDeparture';
+import trackPurchaseAttempt from '@/events/purchaseAttempt';
+import trackSearch from '@/events/search';
+import trackSeatChange from '@/events/seatChange';
+import trackTest from '@/events/test';
+import trackViewResults from '@/events/viewResults';
+import { init } from '@/init';
 
-export { init } from './init';
-export { trackTest } from './events/trackTest';
-
-const tracker = {
+const analytics = {
   init,
-  trackTest,
+  identify,
+  track: {
+    test: trackTest,
+    search: trackSearch,
+    seatChange: trackSeatChange,
+    interestInHome: trackInterestInHome,
+    interestInSearch: trackInterestInSearch,
+    viewResults: trackViewResults,
+    passengersCreated: trackPassengersCreated,
+    paymentAttempt: trackPaymentAttempt,
+    purchaseAttempt: trackPurchaseAttempt,
+    pickedDeparture: trackPickedDeparture,
+  },
 };
 
-export default tracker;
+export type {
+  PassengersCreatedProps,
+  PaymentAttemptProps,
+  SearchProps,
+  SeatChangeProps,
+  ViewResultsProps,
+  InterestInHomeProps,
+  InterestInSearchProps,
+  PurchaseAttemptProps,
+  PickedDepartureProps,
+};
+export default analytics;

package/src/init.ts

@@ -1,9 +1,7 @@
 import { z } from 'zod';
-import validator, {
-  InitConfigSchema,
-} from './events/event_schema/validationSchema';
-import { initFingerprint } from './fingerprint'; // Import the new fingerprint initialization function
-import { initMixpanel, isMixpanelReady } from './mixpanel'; // Import Mixpanel functions
+import fingerprintService from '@/services/fingerprint';
+import mixpanelService from '@/services/mixpanel';
+import validator, { InitConfigSchema } from './services/validator';
 
 /**
  * Configuration object for initializing the tracking library.
@@ -30,11 +28,11 @@ export async function init(config: InitConfig) {
 
   const { mixpanelToken, debug = false, identificationKey } = config;
 
-  await initMixpanel(mixpanelToken, debug);
+  await mixpanelService.init(mixpanelToken, debug);
 
   // Only mixpanel is required to be ready to dispatch the 'Tracker Ready' event
   try {
-    await initFingerprint(identificationKey);
+    await fingerprintService.initFingerprint(identificationKey);
   } catch (error) {
     console.error('Error initializing identification service:', error);
   }
@@ -50,5 +48,5 @@ export async function init(config: InitConfig) {
  * @returns {boolean} Returns true if the Mixpanel tracker is ready, otherwise false.
  */
 export function isTrackerReady(): boolean {
-  return isMixpanelReady();
+  return mixpanelService.isReady();
 }

package/src/{fingerprint.ts → services/fingerprint.ts}

@@ -68,7 +68,7 @@ const setCachedFingerprint = (fingerprint: string): void => {
  * @returns {Promise<void>} A promise that resolves when initialization is complete.
  * @throws {Error} Throws an error if initialization fails.
  */
-export async function initFingerprint(apiKey: string): Promise<void> {
+async function initFingerprint(apiKey: string): Promise<void> {
   window.fingerprintConfig = {};
   window.fpClient = new FpjsClient({
     loadOptions: {
@@ -90,7 +90,7 @@ export async function initFingerprint(apiKey: string): Promise<void> {
  * @returns {Promise<string>} A promise that resolves with the fingerprint.
  * @throws {Error} Throws an error if retrieval fails.
  */
-export async function getFingerprint(cacheOnly = false): Promise<string> {
+async function getFingerprint(cacheOnly = false): Promise<string> {
   if (!window.fingerprintConfig) {
     throw new Error('Fingerprint configuration is not initialized.');
   }
@@ -126,6 +126,14 @@ export async function getFingerprint(cacheOnly = false): Promise<string> {
  * and is ready to use by checking if the `fpClient` instance exists on the window object.
  * @returns {boolean} Returns true if the identification service is ready, otherwise false.
  */
-export function isFingerprintReady(): boolean {
+function isFingerprintReady(): boolean {
   return window.fpClient !== undefined;
 }
+
+const fingerprintService = {
+  initFingerprint,
+  getFingerprint,
+  isFingerprintReady,
+};
+
+export default fingerprintService;

package/src/services/mixpanel.ts

@@ -0,0 +1,89 @@
+import mixpanel from 'mixpanel-browser';
+
+declare global {
+  interface Window {
+    mixpanel: typeof mixpanel;
+  }
+}
+
+/**
+ * Initializes Mixpanel with the provided token and debug flag.
+ * @param {string} mixpanelToken - The Mixpanel token used for authenticating API requests.
+ * @param {boolean} debug - Optional flag to enable or disable debug mode.
+ * @returns {Promise<void>} A promise that resolves when Mixpanel is initialized.
+ */
+function init(mixpanelToken: string, debug = false): Promise<void> {
+  return new Promise<void>((resolve) => {
+    mixpanel.init(mixpanelToken, {
+      debug,
+      loaded: () => {
+        window.mixpanel = mixpanel;
+        resolve();
+      },
+    });
+  });
+}
+
+/**
+ * Identifies a user in Mixpanel and sets their properties.
+ * @param {string} userId - The unique identifier for the user.
+ * @param {Record<string, unknown>} properties - An object containing user properties to be set.
+ * @returns {void}
+ * @throws {Error} If Mixpanel is not initialized (handled internally).
+ */
+function identify(userId: string, properties: Record<string, unknown>): void {
+  if (!isReady()) {
+    return;
+  }
+
+  mixpanel.identify(userId);
+  mixpanel.people.set(properties);
+}
+
+/**
+ * Appends a unique value to a property for the currently identified user in Mixpanel.
+ * If the property doesn't exist, it creates an array with the value.
+ * If the property exists, it adds the value only if it's not already present.
+ * @param {string} key - The name of the property to append to.
+ * @param {unknown} value - The value to append to the property.
+ * @throws {Error} If Mixpanel is not initialized (handled internally).
+ */
+function attachProperty(key: string, value: unknown): void {
+  if (!isReady()) {
+    return;
+  }
+
+  mixpanel.people.union(key, [value]);
+}
+
+/**
+ * Checks if the Mixpanel tracker is ready.
+ * @returns {boolean} Returns true if the Mixpanel tracker is ready, otherwise false.
+ */
+function isReady(): boolean {
+  return window.mixpanel !== undefined;
+}
+/**
+ * Tracks an event in Mixpanel with the given name and properties.
+ * @param {string} eventName - The name of the event to track.
+ * @param {Record<string, unknown>} properties - An object containing event properties.
+ * @returns {void}
+ * @throws {Error} If Mixpanel is not initialized (handled internally).
+ */
+function track(eventName: string, properties: Record<string, unknown>): void {
+  if (!isReady()) {
+    return;
+  }
+
+  mixpanel.track(eventName, properties);
+}
+
+const mixpanelService = {
+  init,
+  isReady,
+  track,
+  identify,
+  attachProperty,
+};
+
+export default mixpanelService;

package/src/services/validator.ts

@@ -0,0 +1,154 @@
+import { z, ZodError, ZodSchema } from 'zod';
+import IdentifySchema from '@/events/identify/identifySchema';
+import { interestInHomeSchema } from '@/events/interestInHome';
+import { interestInSearchSchema } from '@/events/interestInSearch';
+import { passengersCreatedSchema } from '@/events/passengersCreated';
+import { paymentAttemptSchema } from '@/events/paymentAttempt';
+import { pickedDepartureSchema } from '@/events/pickedDeparture';
+import { purchaseAttemptSchema } from '@/events/purchaseAttempt';
+import { searchSchema } from '@/events/search';
+import { seatChangeSchema } from '@/events/seatChange';
+import { viewResultsSchema } from '@/events/viewResults';
+
+const TrackTestEventSchema = z.object({}); // Allow empty object for track test event
+export const InitConfigSchema = z.object({
+  /**
+   * The Mixpanel token used for authenticating API requests.
+   */
+  mixpanelToken: z.string().min(1, 'Mixpanel token is required'),
+  /**
+   * Optional flag to enable or disable debug mode.
+   * When set to true, additional debug information will be logged.
+   */
+  debug: z.boolean().optional(),
+  /**
+   * Key for tracking user identities.
+   */
+  identificationKey: z.string().min(1, 'Identification key is required'),
+});
+interface CustomError {
+  field: string;
+  error_type: string;
+  expected: string;
+  received: string;
+  message: string;
+  suggestion: string;
+}
+// Error formatting
+const SchemaErrorFormatter = (error: ZodError): CustomError[] => {
+  return error.issues.map((issue) => {
+    let error_type = 'INVALID_FIELD';
+    let expected = '';
+    let received = '';
+    let suggestion = '';
+
+    if (issue.code === 'invalid_type') {
+      error_type = 'TYPE_MISMATCH';
+      expected = issue.expected;
+      received = issue.received;
+      suggestion = `Expected ${expected} but received ${received}. Please provide a value of type ${expected}.`;
+    } else if (issue.code === 'too_small') {
+      error_type = 'VALUE_TOO_SMALL';
+      suggestion = `Increase the value to at least ${issue.minimum}.`;
+    } else if (issue.code === 'too_big') {
+      error_type = 'VALUE_TOO_BIG';
+      suggestion = `Reduce the value to no more than ${issue.maximum}.`;
+    } else {
+      error_type = 'INVALID_FIELD';
+      suggestion = `Ensure the field matches the expected format and value type.`;
+    }
+    return {
+      field: issue.path.join('.'),
+      error_type,
+      expected,
+      received,
+      message: issue.message,
+      suggestion,
+    };
+  });
+};
+
+// Mapping event names to Zod schemas
+const eventSchemas: Record<string, z.ZodSchema> = {
+  'Track Test': TrackTestEventSchema,
+  'Search': searchSchema,
+  'Seat Change': seatChangeSchema,
+  'Interest In Home': interestInHomeSchema,
+  'Passengers Created': passengersCreatedSchema,
+  'Payment Attempt': paymentAttemptSchema,
+  'Interest In Search': interestInSearchSchema,
+  'View Results': viewResultsSchema,
+  'Purchase Attempt': purchaseAttemptSchema,
+  'Picked Departure': pickedDepartureSchema,
+};
+
+type EventData = z.infer<(typeof eventSchemas)[keyof typeof eventSchemas]>;
+
+/**
+ * Validates the event data against the predefined schema for the given event name.
+ * @param {string} eventName - The name of the event to validate.
+ * @param {EventData} eventData - The data of the event to validate.
+ * @throws {Error} - Throws an error if validation fails.
+ */
+function parseEventProps(eventName: string, eventData: EventData): void {
+  const eventSchema = eventSchemas[eventName];
+
+  if (!eventSchema) {
+    throw { message: `Event ${eventName} not found` };
+  }
+
+  try {
+    eventSchema.parse(eventData);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      const errors = SchemaErrorFormatter(error);
+      throw { message: 'Schema validation failed', errors };
+    }
+    throw { message: 'Unknown validation error' };
+  }
+}
+
+/**
+ * Generic function to validate properties against a given schema.
+ * @param {object} properties - The properties to validate.
+ * @param {ZodSchema} schema - The schema to validate against.
+ * @throws {Error} - Throws an error if validation fails.
+ */
+function validateProps(properties: object, schema: ZodSchema): void {
+  try {
+    schema.parse(properties);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      const errors = SchemaErrorFormatter(error);
+      throw { message: 'Schema validation failed', errors };
+    }
+    throw { message: 'Unknown validation error' };
+  }
+}
+
+/**
+ * Validates the initialization properties.
+ * @param {object} initProps - The properties to validate for init.
+ * @throws {Error} - Throws an error if validation fails.
+ */
+function parseInitProps(initProps: object): void {
+  validateProps(initProps, InitConfigSchema);
+}
+
+/**
+ * Validates the properties for user identification.
+ * @param {Record<string, unknown>} properties - The properties to validate for user identification.
+ * @throws {Error} - Throws an error if validation fails.
+ */
+function parseIdentifyProps(properties: Record<string, unknown>): void {
+  validateProps(properties, IdentifySchema);
+}
+
+const validatorService = {
+  parseEventProps,
+  parseInitProps,
+  parseIdentifyProps,
+};
+
+// Export the validator object
+export default validatorService;

package/src/track.ts

@@ -1,12 +1,11 @@
-import mixpanel from 'mixpanel-browser';
-import validator from './events/event_schema/validationSchema';
-import { getFingerprint } from './fingerprint';
-import { isMixpanelReady } from './mixpanel';
+import fingerprintService from '@/services/fingerprint';
+import mixpanelService from '@/services/mixpanel';
+import validator from '@/services/validator';
 
 /**
  * List of events that trigger the fingerprint to be sent with the event. other eventes will only fetch the cached fingerprint.
  */
-const FP_TRIGGER_EVENTS = ['Track Test'];
+const FP_TRIGGER_EVENTS = ['Search', 'View Results'];
 
 /**
  * Base function to track events with Mixpanel.
@@ -19,20 +18,15 @@ export async function trackEvent(
   eventName: string,
   eventProperties: object,
 ): Promise<void> {
-  if (!isMixpanelReady()) {
+  if (!mixpanelService.isReady()) {
     throw new Error('Mixpanel is not initialized.');
   }
 
   try {
-    const validationResult = validator.parseEventProps(
-      eventName,
-      eventProperties,
-    );
-    console.log('validation schema result===>', validationResult);
-
+    validator.parseEventProps(eventName, eventProperties);
     const cacheOnly = !FP_TRIGGER_EVENTS.includes(eventName);
 
-    const fingerprint = await getFingerprint(cacheOnly);
+    const fingerprint = await fingerprintService.getFingerprint(cacheOnly);
     const defaultProperties = {
       'User Fingerprint': fingerprint,
     };
@@ -42,9 +36,8 @@ export async function trackEvent(
       ...eventProperties,
     };
 
-    mixpanel.track(eventName, properties);
+    mixpanelService.track(eventName, properties);
   } catch (error) {
     console.error('Error tracking event:', error);
-    throw error;
   }
 }

package/src/util/dateValidation.ts

@@ -0,0 +1,26 @@
+/**
+ * Validates a date string to ensure it matches specific date formats.
+ * @param {string} val - The date string to validate.
+ * @returns {boolean} True if the date string is valid, false otherwise.
+ */
+const dateValidation = (val: string): boolean => {
+  // Check for valid date format (YYYY-MM-DD) or datetime format (YYYY-MM-DDTHH:mm:ss)
+  const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+  const dateTimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/;
+
+  // New regex to ensure at least YYYY-MM-DD is provided
+  const minimalDateRegex = /^\d{4}-\d{2}-\d{2}/;
+
+  if (dateRegex.test(val) || dateTimeRegex.test(val)) {
+    return true;
+  }
+
+  // Check if the string starts with YYYY-MM-DD and is a valid date
+  if (minimalDateRegex.test(val) && !isNaN(Date.parse(val))) {
+    return true;
+  }
+
+  return false;
+};
+
+export default dateValidation;

package/src/util/productValidation.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import PRODUCT_TYPES, { ProductType } from '@/constants/ProductTypes';
+
+const productValidation = z
+  .enum(PRODUCT_TYPES)
+  .refine((val): val is ProductType => PRODUCT_TYPES.includes(val), {
+    message: `Product must be one of: ${PRODUCT_TYPES.join(', ')}`,
+  });
+
+export default productValidation;

package/src/util/userFingerprintValidation.ts

@@ -0,0 +1,9 @@
+/**
+ * Validates the user fingerprint value.
+ * @param {null | string} val - The user fingerprint value to validate.
+ * @returns {boolean} True if the value is either null or a string, false otherwise.
+ */
+const userFingerPrintValidation = (val: null | string) =>
+  val === null || typeof val === 'string';
+
+export default userFingerPrintValidation;