@reservamos/browser-analytics 0.1.4-alpha.9 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reservamos/browser-analytics",
-  "version": "0.1.4-alpha.9",
+  "version": "0.2.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/reservamos/reservamos-browser-analytics.git"
@@ -86,6 +86,7 @@
   "typings": "./dist/reservamos-browser-analytics.d.ts",
   "dependencies": {
     "@fingerprintjs/fingerprintjs-pro-spa": "^1.3.2",
+    "@reservamos/js-api-client": "5.26.0",
     "mixpanel-browser": "^2.55.1",
     "zod": "^3.23.8"
   }

package/src/events/customEvent/customEventSchema.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+const allowedPrimitiveSchema = z.union([
+  z.string(),
+  z.boolean(),
+  z.number(),
+  z.undefined(),
+]);
+
+const customEventSchema = z.record(
+  z.string(),
+  z.union([allowedPrimitiveSchema, z.array(allowedPrimitiveSchema)]),
+);
+
+type CustomEventProps = z.infer<typeof customEventSchema>;
+
+const eventNameSchema = z.string().min(1, 'Event name is required');
+export type { CustomEventProps };
+export  {customEventSchema, eventNameSchema} ;

package/src/events/customEvent/index.ts

@@ -0,0 +1,7 @@
+import type { CustomEventProps } from './customEventSchema';
+import { customEventSchema } from './customEventSchema';
+import trackCustomEvent from './trackCustomEvent';
+
+export type { CustomEventProps };
+export { customEventSchema };
+export default trackCustomEvent;

package/src/events/customEvent/trackCustomEvent.ts

@@ -0,0 +1,19 @@
+import { trackEvent } from '@/track';
+import EventData from '@/types/eventData';
+import { eventNameSchema } from './customEventSchema';
+
+/**
+ * Tracks a custom event with any event name, data, and metadata.
+ * @param {string} eventName - The name of the custom event.
+ * @param {EventData} eventData - Additional data to include in the event.
+ */
+function trackCustomEvent(eventName: string, eventData: EventData = {}): void {
+  try {
+    eventNameSchema.parse(eventName);
+    trackEvent(eventName, eventData);
+  } catch (error) {
+    console.error('Error trackCustomEvent:', error);
+    return;
+  }
+}
+export default trackCustomEvent;

package/src/events/identify/identify.ts

@@ -1,3 +1,4 @@
+import createAnonymousProfile from '@/profiles/createAnonymousProfile';
 import validatorService from '@/services/validator';
 import fingerprintService from '../../services/fingerprint';
 import mixpanelService from '../../services/mixpanel';
@@ -51,31 +52,37 @@ function mapProperties(properties: UserProperties): Record<string, unknown> {
  * @throws {Error} If analytics service is not initialized or userId is missing.
  * @returns {Promise<void>}
  */
-export async function identify(
+async function identify(
   userId: string,
   properties: UserProperties = {},
 ): Promise<void> {
-  if (!mixpanelService.isReady()) {
-    throw new Error('Analytics service is not initialized');
-  }
-
   try {
+    if (!mixpanelService.isReady()) {
+      console.error('Mixpanel is not initialized.');
+      throw new Error('Mixpanel is not initialized.');
+    }
+
     validatorService.parseIdentifyProps(properties);
 
     if (!userId) {
-      throw new Error('User ID is required');
+      console.error('User ID is required for identification.');
+      throw new Error('User ID is required for identification.');
     }
 
     const mappedProps = mapProperties(properties);
-
     mixpanelService.identify(userId, mappedProps);
-
     const fingerprint = await fingerprintService.getFingerprint();
-
     if (fingerprint) {
       mixpanelService.attachProperty(FINGERPRINT_PROPERTY, fingerprint);
     }
   } catch (error) {
-    console.error('Error attaching fingerprint:', error);
+    console.error('Error identifying user', error);
+  } finally {
+    createAnonymousProfile({
+      email: properties.email,
+      phone: properties.phone,
+    });
   }
 }
+
+export default identify;

package/src/events/identify/identifySchema.ts

@@ -10,6 +10,7 @@ const IdentifySchema = z.object({
     .optional(),
 });
 
-export type DefaultProperties = z.infer<typeof IdentifySchema>;
+type DefaultProperties = z.infer<typeof IdentifySchema>;
 
+export type { DefaultProperties };
 export default IdentifySchema;

package/src/events/identify/index.ts

@@ -1,3 +1,5 @@
-import { identify } from './identify';
+import type { DefaultProperties } from './identifySchema';
+import identify from './identify';
 
+export type { DefaultProperties };
 export default identify;

package/src/events/interestInHome/trackInterestInHome.ts

@@ -1,14 +1,19 @@
 import type { InterestInHomeProps } from './interestInHomeSchema';
 import { trackEvent } from '@/track';
+import EventData from '@/types/eventData';
 
 const EVENT_NAME = 'Interest In Home';
 
 /**
  * Tracks a Interest In Home event.
  * @param {InterestInHomeProps} eventData - The data associated with the Interest In Home event.
+ * @param {EventData} meta - Additional metadata to include in the event.
  */
-function trackInterestInHome(eventData: InterestInHomeProps) {
-  trackEvent(EVENT_NAME, eventData);
+function trackInterestInHome(
+  eventData: InterestInHomeProps,
+  meta: EventData = {},
+): void {
+  trackEvent(EVENT_NAME, eventData, meta);
 }
 
 export default trackInterestInHome;

package/src/events/interestInSearch/trackInterestInSearch.ts

@@ -1,14 +1,19 @@
 import type { InterestInSearchProps } from './interestInSearchSchema';
 import { trackEvent } from '@/track';
+import EventData from '@/types/eventData';
 
 const EVENT_NAME = 'Interest In Search';
 
 /**
  * Tracks a Interest In Search event.
  * @param {InterestInSearchProps} eventData - The data associated with the Interest In Search event.
+ * @param {EventData} meta - Additional metadata to include in the event.
  */
-function trackInterestInSearch(eventData: InterestInSearchProps) {
-  trackEvent(EVENT_NAME, eventData);
+function trackInterestInSearch(
+  eventData: InterestInSearchProps,
+  meta: EventData = {},
+): void {
+  trackEvent(EVENT_NAME, eventData, meta);
 }
 
 export default trackInterestInSearch;

package/src/events/passengersCreated/passengersCreatedSchema.ts

@@ -1,54 +1,17 @@
 import { z } from 'zod';
-import dateValidation from '@/util/dateValidation';
+import { arrayField, intField, numberField } from '@/util/primitiveFields';
 import productValidation from '@/util/productValidation';
+import tripSchema from '../sharedSchemas/tripSchema';
 
-const passengersCreatedSchema = z.object({
-  'Departure Arrival': z.string().refine(dateValidation, {
-    message:
-      'Invalid departure arrival datetime format. Must include at least YYYY-MM-DD',
-  }),
-  'Departure Destination': z
-    .string()
-    .min(1, 'Departure Destination is required'),
-  'Departure Destination Terminal': z
-    .string()
-    .min(1, 'Departure Destination Terminal is required'),
-  'Departure Line': z.string().min(1, 'Departure Line is required'),
-  'Departure Origin': z.string().min(1, 'Departure Origin is required'),
-  'Departure Origin Terminal': z
-    .string()
-    .min(1, 'Departure Origin Terminal is required'),
-  'Departure Price': z
-    .number()
-    .positive('Departure Price must be a positive number'),
-  'Departure Route': z.string().min(1, 'Departure Route is required'),
-  'Departure Stops': z
-    .number()
-    .int('Departure Stops must be an integer')
-    .nonnegative()
-    .optional(),
-  'Departure Time': z.string().refine(dateValidation, {
-    message:
-      'Invalid departure time datetime format. Must include at least YYYY-MM-DD',
-  }),
-  'Departure Transporter': z
-    .string()
-    .min(1, 'Departure Transporter is required'),
-  'Passenger Count': z
-    .number()
-    .int('Passenger Count must be an integer')
-    .positive(),
-  'Recommended Trip': z.boolean(),
-  'Recommended Trip Type': z.string().optional(),
-  'Routes': z.number().int('Routes must be an integer').positive(),
-  'Total': z.number().positive('Total must be a positive number'),
-  'Trip Length': z
-    .number()
-    .int('Trip Length must be an integer')
-    .nonnegative()
-    .optional(),
-  'product': productValidation,
-});
+const passengersCreatedSchema = z
+  .object({
+    'Trips': arrayField(tripSchema, 'Trips', 1),
+    'Passenger Count': intField('Passenger Count'),
+    'Trip Count': intField('Trip Count').optional(),
+    'Total': numberField('Total'),
+    'product': productValidation,
+  })
+  .strict();
 
 type PassengersCreatedProps = z.infer<typeof passengersCreatedSchema>;
 

package/src/events/passengersCreated/trackPassengersCreated.ts

@@ -1,10 +1,19 @@
 import type { PassengersCreatedProps } from './passengersCreatedSchema';
 import { trackEvent } from '@/track';
+import EventData from '@/types/eventData';
 
 const EVENT_NAME = 'Passengers Created';
 
-const trackPassengersCreated = async (eventProps: PassengersCreatedProps) => {
-  trackEvent(EVENT_NAME, eventProps);
-};
+/**
+ * Tracks a Passengers Created event.
+ * @param {PassengersCreatedProps} eventProps - The data associated with the Passengers Created event.
+ * @param {EventData} meta - Additional metadata to include in the event.
+ */
+function trackPassengersCreated(
+  eventProps: PassengersCreatedProps,
+  meta: EventData = {},
+): void {
+  trackEvent(EVENT_NAME, eventProps, meta);
+}
 
 export default trackPassengersCreated;

package/src/events/paymentAttempt/paymentAttemptSchema.ts

@@ -1,51 +1,18 @@
 import { z } from 'zod';
-import dateValidation from '@/util/dateValidation';
+import { arrayField, intField, numberField } from '@/util/primitiveFields';
 import productValidation from '@/util/productValidation';
+import tripSchema from '../sharedSchemas/tripSchema';
 
-const paymentAttemptSchema = z.object({
-  'Departure Arrival': z.string().refine(dateValidation, {
-    message:
-      'Invalid departure arrival datetime format. Must include at least YYYY-MM-DD',
-  }),
-  'Departure Destination': z
-    .string()
-    .min(1, 'Departure Destination is required'),
-  'Departure Destination Terminal': z
-    .string()
-    .min(1, 'Departure Destination Terminal is required'),
-  'Departure Line': z.string().min(1, 'Departure Line is required'),
-  'Departure Origin': z.string().min(1, 'Departure Origin is required'),
-  'Departure Origin Terminal': z
-    .string()
-    .min(1, 'Departure Origin Terminal is required'),
-  'Departure Price': z
-    .number()
-    .positive('Departure Price must be a positive number'),
-  'Departure Route': z.string().min(1, 'Departure Route is required'),
-  'Departure Stop Cities': z.string().optional(),
-  'Departure Stops': z
-    .number()
-    .int('Departure Stops must be an integer')
-    .nonnegative()
-    .optional(),
-  'Departure Time': z.string().refine(dateValidation, {
-    message:
-      'Invalid departure time datetime format. Must include at least YYYY-MM-DD',
-  }),
-  'Departure Transporter': z
-    .string()
-    .min(1, 'Departure Transporter is required'),
-  'Passenger Count': z
-    .number()
-    .int('Passenger Count must be an integer')
-    .positive(),
-  'Payment Type': z.string().min(1, 'Payment Type is required'),
-  'Recommended Trip': z.boolean(),
-  'Recommended Trip Type': z.string().optional(),
-  'Routes': z.number().int('Routes must be an integer').positive(),
-  'Total': z.number().positive('Total must be a positive number'),
-  'product': productValidation,
-});
+const paymentAttemptSchema = z
+  .object({
+    'Trips': arrayField(tripSchema, 'Trips', 1),
+    'Passenger Count': intField('Passenger Count'),
+    'Trip Count': intField('Trip Count'),
+    'Payment Type': z.string().min(1, 'Payment Type is required'),
+    'Total': numberField('Total'),
+    'product': productValidation,
+  })
+  .strict();
 
 type PaymentAttemptProps = z.infer<typeof paymentAttemptSchema>;
 

package/src/events/pickedDeparture/pickedDepartureSchema.ts

@@ -24,15 +24,8 @@ const pickedDepartureSchema = z.object({
   'Transport Type': z.string().min(1, 'Transport Type is required'),
   'Transporter': z.string().min(1, 'Transporter is required'),
   'product': productValidation,
-  'Recommended Trip': z.boolean().refine((val) => val, {
-    message: 'Recommended Trip must be a boolean',
-  }),
-  'Recommended Trip Type': z
-    .string()
-    .or(z.null())
-    .refine((val) => val === null || typeof val === 'string', {
-      message: 'Recommended Trip Type must be a string or null',
-    }),
+  'Recommended Trip': z.boolean(),
+  'Recommended Trip Type': z.string().optional(),
 });
 
 type PickedDepartureProps = z.infer<typeof pickedDepartureSchema>;

package/src/events/pickedDeparture/trackPickedDeparture.ts

@@ -1,14 +1,19 @@
 import type { PickedDepartureProps } from './pickedDepartureSchema';
 import { trackEvent } from '@/track';
+import EventData from '@/types/eventData';
 
 const EVENT_NAME = 'Picked Departure';
 
 /**
  * Tracks a Picked Departure event.
  * @param {PickedDepartureProps} eventData - The data associated with the Picked Departure event.
+ * @param {EventData} meta - Additional metadata to include in the event.
  */
-function trackSearch(eventData: PickedDepartureProps) {
-  trackEvent(EVENT_NAME, eventData);
+function trackSearch(
+  eventData: PickedDepartureProps,
+  meta: EventData = {},
+): void {
+  trackEvent(EVENT_NAME, eventData, meta);
 }
 
 export default trackSearch;

package/src/events/purchaseAttempt/purchaseAttemptSchema.ts

@@ -1,75 +1,15 @@
 import { z } from 'zod';
-import dateValidation from '@/util/dateValidation';
+import { arrayField, intField, numberField } from '@/util/primitiveFields';
 import productValidation from '@/util/productValidation';
+import tripSchema from '../sharedSchemas/tripSchema';
 
 const purchaseAttemptSchema = z
   .object({
-    'Departure Arrival': z.string().refine(dateValidation, {
-      message: 'Invalid departure arrival datetime format',
-    }),
-    'Departure Destination': z.string().refine((val) => val, {
-      message: 'Departure Destination must be a string',
-    }),
-    'Departure Destination Terminal': z.string().refine((val) => val, {
-      message: 'Departure Destination Terminal must be a string',
-    }),
-    'Departure Line': z.string().refine((val) => val, {
-      message: 'Departure Line must be a string',
-    }),
-    'Departure Origin': z.string().refine((val) => val, {
-      message: 'Departure Origin must be a string',
-    }),
-    'Departure Origin Terminal': z.string().refine((val) => val, {
-      message: 'Departure Origin Terminal must be a string',
-    }),
-    'Departure Price': z.number().refine((val) => val, {
-      message: 'Departure Price must be a number',
-    }),
-    'Departure Route': z.string().refine((val) => val, {
-      message: 'Departure Route must be a string',
-    }),
-    'Departure Stops': z
-      .number()
-      .int()
-      .refine((val) => val, {
-        message: 'Departure Stops must be an integer',
-      }),
-    'Departure Time': z.string().refine(dateValidation, {
-      message: 'Invalid departure time datetime format',
-    }),
-    'Departure Transport Type': z.string().refine((val) => val, {
-      message: 'Departure Transport Type must be a string',
-    }),
-    'Departure Transporter': z.string().refine((val) => val, {
-      message: 'Departure Transporter must be a string',
-    }),
-    'Passenger Count': z
-      .number()
-      .int()
-      .refine((val) => val, {
-        message: 'Passenger Count must be an integer',
-      }),
-    'Recommended Trip': z.boolean().refine((val) => val, {
-      message: 'Recommended Trip must be a boolean',
-    }),
-    'Recommended Trip Type': z
-      .string()
-      .or(z.null())
-      .refine((val) => val === null || typeof val === 'string', {
-        message: 'Recommended Trip Type must be a string or null',
-      })
-      .optional(),
-    'Routes': z
-      .number()
-      .int()
-      .refine((val) => val, {
-        message: 'Routes must be an integer',
-      }),
-    'Total': z.number().refine((val) => val, {
-      message: 'Total must be a number',
-    }),
+    'Trips': arrayField(tripSchema, 'Trips', 1),
+    'Passenger Count': intField('Passenger Count'),
+    'Trip Count': intField('Trip Count'),
+    'Total': numberField('Total'),
     'product': productValidation,
-    'Trip Length': z.number().int().optional(),
   })
   .strict();
 

package/src/events/purchaseAttempt/trackPurchaseAttempt.ts

@@ -1,14 +1,19 @@
 import type { PurchaseAttemptProps } from './purchaseAttemptSchema';
 import { trackEvent } from '@/track';
+import EventData from '@/types/eventData';
 
 const EVENT_NAME = 'Purchase Attempt';
 
 /**
  * Tracks a Purchase Attempt event.
  * @param {PurchaseAttemptProps} eventData - The data associated with the Purchase Attempt event.
+ * @param {EventData} meta - Additional metadata to include in the event.
  */
-function trackSearch(eventData: PurchaseAttemptProps) {
-  trackEvent(EVENT_NAME, eventData);
+function trackPurchaseAttempt(
+  eventData: PurchaseAttemptProps,
+  meta: EventData = {},
+): void {
+  trackEvent(EVENT_NAME, eventData, meta);
 }
 
-export default trackSearch;
+export default trackPurchaseAttempt;

package/src/events/search/trackSearch.ts

@@ -1,14 +1,16 @@
 import type { SearchProps } from './searchSchema';
 import { trackEvent } from '@/track';
+import EventData from '@/types/eventData';
 
 const EVENT_NAME = 'Search';
 
 /**
  * Tracks a search event.
  * @param {SearchProps} eventData - The data associated with the search event.
+ * @param {EventData} meta - Additional metadata to include in the event.
  */
-function trackSearch(eventData: SearchProps) {
-  trackEvent(EVENT_NAME, eventData);
+function trackSearch(eventData: SearchProps, meta: EventData = {}): void {
+  trackEvent(EVENT_NAME, eventData, meta);
 }
 
 export default trackSearch;

package/src/events/seatChange/trackSeatChange.ts

@@ -1,10 +1,19 @@
 import type { SeatChangeProps } from './seatChangeSchema';
 import { trackEvent } from '@/track';
+import EventData from '@/types/eventData';
 
 const EVENT_NAME = 'Seat Change';
 
-const trackSeatChange = async (eventProps: SeatChangeProps) => {
-  trackEvent(EVENT_NAME, eventProps);
-};
+/**
+ * Tracks a Seat Change event.
+ * @param {SeatChangeProps} eventProps - The data associated with the Seat Change event.
+ * @param {EventData} meta - Additional metadata to include in the event.
+ */
+function trackSeatChange(
+  eventProps: SeatChangeProps,
+  meta: EventData = {},
+): void {
+  trackEvent(EVENT_NAME, eventProps, meta);
+}
 
 export default trackSeatChange;

package/src/events/sharedSchemas/tripSchema.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import {
+  dateField,
+  intField,
+  numberField,
+  stringField,
+} from '@/util/primitiveFields';
+
+const tripSchema = z.object({
+  'Departure Arrival': dateField('Departure Arrival'),
+  'Departure Destination': stringField('Departure Destination'),
+  'Departure Destination Terminal': stringField(
+    'Departure Destination Terminal',
+  ),
+  'Departure Line': stringField('Departure Line'),
+  'Departure Origin': stringField('Departure Origin'),
+  'Departure Origin Terminal': stringField('Departure Origin Terminal'),
+  'Departure Price': numberField('Departure Price'),
+  'Departure Route': stringField('Departure Route'),
+  'Departure Stops': intField('Departure Stops'),
+  'Departure Time': dateField('Departure Time'),
+  'Departure Transport Type': stringField('Departure Transport Type'),
+  'Departure Transporter': stringField('Departure Transporter'),
+  'Return Arrival': dateField('Return Arrival').optional(),
+  'Return Destination': stringField('Return Destination').optional(),
+  'Return Destination Terminal': stringField(
+    'Return Destination Terminal',
+  ).optional(),
+  'Return Line': stringField('Return Line').optional(),
+  'Return Origin': stringField('Return Origin').optional(),
+  'Return Origin Terminal': stringField('Return Origin Terminal').optional(),
+  'Return Price': numberField('Return Price').optional(),
+  'Return Route': stringField('Return Route').optional(),
+  'Return Stops': intField('Return Stops').optional(),
+  'Return Time': dateField('Return Time').optional(),
+  'Return Transport Type': stringField('Return Transport Type').optional(),
+  'Return Transporter': stringField('Return Transporter').optional(),
+  'Recommended Trip': z.boolean(),
+  'Recommended Trip Type': stringField('Recommended Trip Type').optional(),
+});
+
+export default tripSchema;

package/src/events/viewResults/trackViewResults.ts

@@ -1,14 +1,19 @@
 import type { ViewResultsProps } from './viewResultsSchema';
 import { trackEvent } from '@/track';
+import EventData from '@/types/eventData';
 
 const EVENT_NAME = 'View Results';
 
 /**
  * Tracks a View Results event.
  * @param {ViewResultsProps} eventData - The data associated with the View Results event.
+ * @param {EventData} meta - Additional metadata to include in the event.
  */
-function trackViewResults(eventData: ViewResultsProps) {
-  trackEvent(EVENT_NAME, eventData);
+function trackViewResults(
+  eventData: ViewResultsProps,
+  meta: EventData = {},
+): void {
+  trackEvent(EVENT_NAME, eventData, meta);
 }
 
 export default trackViewResults;

package/src/index.ts

@@ -1,3 +1,4 @@
+import type { CustomEventProps } from '@/events/customEvent';
 import type { InterestInHomeProps } from '@/events/interestInHome';
 import type { InterestInSearchProps } from '@/events/interestInSearch';
 import type { PassengersCreatedProps } from '@/events/passengersCreated';
@@ -7,6 +8,8 @@ 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 type { CreateAnonymousProfileProps } from '@/profiles/createAnonymousProfile';
+import trackCustomEvent from '@/events/customEvent';
 import identify from '@/events/identify';
 import trackInterestInHome from '@/events/interestInHome';
 import trackInterestInSearch from '@/events/interestInSearch';
@@ -19,10 +22,21 @@ import trackSeatChange from '@/events/seatChange';
 import trackTest from '@/events/test';
 import trackViewResults from '@/events/viewResults';
 import { init } from '@/init';
+import createAnonymousProfile from '@/profiles/createAnonymousProfile';
+import fingerprintService from '@/services/fingerprint';
+import mixpanelService from '@/services/mixpanel';
+import './js-api-client.d.ts';
 
 const analytics = {
   init,
   identify,
+  identifiers: {
+    getFingerprintId: fingerprintService.getCachedFingerprint,
+    getDistinctId: mixpanelService.getMixpanelDistinctId,
+  },
+  profiles: {
+    createAnonymousProfile,
+  },
   track: {
     test: trackTest,
     search: trackSearch,
@@ -34,6 +48,7 @@ const analytics = {
     paymentAttempt: trackPaymentAttempt,
     purchaseAttempt: trackPurchaseAttempt,
     pickedDeparture: trackPickedDeparture,
+    customEvent: trackCustomEvent,
   },
 };
 
@@ -47,5 +62,7 @@ export type {
   InterestInSearchProps,
   PurchaseAttemptProps,
   PickedDepartureProps,
+  CustomEventProps,
+  CreateAnonymousProfileProps,
 };
 export default analytics;