@reservamos/browser-analytics 1.1.8-alpha.2 → 1.1.8-alpha.3

package/src/services/profileEnrichment.ts

@@ -0,0 +1,258 @@
+import type { IdentifyReporter } from '@/util/identifyAttempt';
+import { z } from 'zod';
+import {
+  createAnonymousProfileForIdentify,
+  prepareAnonymousProfileForIdentify,
+  requestPreparedAnonymousProfile,
+} from '@/profiles/createAnonymousProfile/createAnonymousProfile';
+import mixpanelService from '@/services/mixpanel';
+import trackingLifecycle from '@/services/trackingLifecycle';
+import {
+  createIdentifyReporter,
+  waitForIdentifyStage,
+} from '@/util/identifyAttempt';
+
+const STORAGE_KEY = 'reservamos_pending_profile_v1';
+const LIFETIME_MS = 10 * 60 * 1000;
+const MAX_ATTEMPTS = 3;
+const MAX_BYTES = 4096;
+const profileIdSchema = z.union([
+  z.string().min(1),
+  z.number().int().positive(),
+]);
+const requestSchema = z
+  .object({
+    identifier_key: z.enum(['email', 'phone']),
+    identifier_value: z.string().min(1),
+    identifiers: z.array(
+      z.object({ key: z.string().min(1), value: z.string().min(1) }).strict(),
+    ),
+    details: z.record(z.string()),
+  })
+  .strict();
+const pendingSchema = z
+  .object({
+    version: z.literal(1),
+    id: z.string().min(1),
+    userId: z.string().min(1),
+    scope: z.string().min(1),
+    expiresAt: z.number().int(),
+    attempts: z.number().int().min(1).max(MAX_ATTEMPTS),
+    request: requestSchema.optional(),
+    profileId: profileIdSchema.optional(),
+  })
+  .strict()
+  .refine((entry) => entry.request || entry.profileId);
+type PendingProfile = z.infer<typeof pendingSchema>;
+interface ProfileLink {
+  id: z.infer<typeof profileIdSchema>;
+}
+interface RecoveryScope {
+  project: string;
+  proxy?: string;
+  apiBaseUrl: string;
+  appName?: string;
+}
+let scope: string | undefined;
+let generation = 0;
+
+function remove(report: IdentifyReporter, id?: string): void {
+  try {
+    if (id) {
+      const stored = JSON.parse(
+        sessionStorage.getItem(STORAGE_KEY) || 'null',
+      ) as PendingProfile | null;
+      if (stored?.id !== id) return;
+    }
+    sessionStorage.removeItem(STORAGE_KEY);
+  } catch {
+    report('cache', 'unavailable');
+  }
+}
+
+function save(entry: PendingProfile, report: IdentifyReporter): boolean {
+  try {
+    const serialized = JSON.stringify(entry);
+    if (new Blob([serialized]).size > MAX_BYTES) {
+      remove(report);
+      report('cache', 'unavailable');
+      return false;
+    }
+    sessionStorage.setItem(STORAGE_KEY, serialized);
+    return true;
+  } catch {
+    remove(report);
+    report('cache', 'unavailable');
+    return false;
+  }
+}
+
+function read(report: IdentifyReporter): PendingProfile | undefined {
+  try {
+    const serialized = sessionStorage.getItem(STORAGE_KEY);
+    if (!serialized) return undefined;
+    if (new Blob([serialized]).size > MAX_BYTES) throw new Error();
+    const entry = pendingSchema.parse(JSON.parse(serialized));
+    if (
+      entry.expiresAt <= Date.now() ||
+      entry.expiresAt > Date.now() + LIFETIME_MS
+    ) {
+      remove(report);
+      return undefined;
+    }
+    return entry;
+  } catch {
+    remove(report);
+    report('cache', 'unavailable');
+    return undefined;
+  }
+}
+
+function currentUserIs(userId: string): boolean {
+  return (
+    mixpanelService.isReady() &&
+    mixpanelService.getMixpanelDistinctId() === userId
+  );
+}
+
+async function resolveProfile(
+  userId: string,
+  properties: Record<string, string | number | boolean | undefined>,
+  isCurrent: () => boolean,
+  report: IdentifyReporter,
+  entry?: PendingProfile,
+  recovering = false,
+): Promise<ProfileLink | undefined> {
+  if (!isCurrent()) return undefined;
+  const profile =
+    entry?.profileId !== undefined
+      ? { id: entry.profileId }
+      : await waitForIdentifyStage(
+          'profile',
+          3000,
+          (context) =>
+            isCurrent()
+              ? entry?.request
+                ? requestPreparedAnonymousProfile(entry.request)
+                : createAnonymousProfileForIdentify(
+                    { ...properties },
+                    context.report,
+                  )
+              : Promise.resolve(undefined),
+          report,
+        );
+  if (!isCurrent()) return undefined;
+  if (!profile) {
+    if (entry && entry.attempts >= MAX_ATTEMPTS) remove(report, entry.id);
+    return undefined;
+  }
+  const parsedId = profileIdSchema.safeParse(profile.id);
+  if (!parsedId.success) {
+    report('profile', 'failed');
+    return undefined;
+  }
+  const profileId = parsedId.data;
+  if (entry) save({ ...entry, request: undefined, profileId }, report);
+  const accepted = () => {
+    if (entry && isCurrent()) remove(report, entry.id);
+  };
+  try {
+    const properties = { reservamos_one_id: profileId };
+    if (recovering) {
+      mixpanelService.restorePeopleProperties(
+        userId,
+        properties,
+        report,
+        accepted,
+      );
+    } else if (entry) {
+      mixpanelService.setPeopleProperties(properties, report, accepted);
+    } else {
+      mixpanelService.setPeopleProperties(properties, report);
+    }
+  } catch {
+    report('profile', 'failed');
+  }
+  return { id: profileId };
+}
+
+/** Records the original normalized request while preserving the ordinary in-memory enrichment. */
+function enrich(
+  userId: string,
+  properties: Record<string, string | number | boolean | undefined>,
+  isActive: () => boolean,
+  report: IdentifyReporter,
+): Promise<ProfileLink | undefined> {
+  if (!isActive()) return Promise.resolve(undefined);
+  const attempt = ++generation;
+  let request: z.infer<typeof requestSchema> | undefined;
+  if (scope) {
+    try {
+      const prepared = requestSchema.safeParse(
+        prepareAnonymousProfileForIdentify({ ...properties }, report),
+      );
+      if (prepared.success) request = prepared.data;
+    } catch {
+      // The ordinary bounded request below retains its existing validation handling.
+    }
+  }
+  const entry: PendingProfile | undefined =
+    scope && request
+      ? {
+          version: 1,
+          id: `${Date.now()}-${Math.random()}`,
+          userId,
+          scope,
+          expiresAt: Date.now() + LIFETIME_MS,
+          attempts: 1,
+          request,
+        }
+      : undefined;
+  if (entry) save(entry, report);
+  else if (scope) remove(report);
+  const isCurrent = () =>
+    attempt === generation &&
+    isActive() &&
+    (!entry || Date.now() < entry.expiresAt) &&
+    (!scope || currentUserIs(userId));
+  return resolveProfile(userId, properties, isCurrent, report, entry);
+}
+
+/** Resumes only matching tab-local work after Mixpanel and Core configuration are ready. */
+function initialize(configuration: RecoveryScope): void {
+  scope = JSON.stringify([
+    configuration.project,
+    configuration.proxy ?? '',
+    configuration.apiBaseUrl,
+    configuration.appName ?? '',
+  ]);
+  const attempt = ++generation;
+  const report = createIdentifyReporter();
+  const entry = read(report);
+  if (!entry) return;
+  if (
+    entry.scope !== scope ||
+    !currentUserIs(entry.userId) ||
+    (entry.profileId === undefined && entry.attempts >= MAX_ATTEMPTS)
+  ) {
+    remove(report, entry.id);
+    return;
+  }
+  const lifecycle = trackingLifecycle.capture();
+  const isCurrent = () =>
+    attempt === generation &&
+    lifecycle() &&
+    Date.now() < entry.expiresAt &&
+    currentUserIs(entry.userId);
+  const resumed = {
+    ...entry,
+    attempts: entry.attempts + (entry.profileId === undefined ? 1 : 0),
+  };
+  if (entry.profileId === undefined && !save(resumed, report)) return;
+  const scopedReport: IdentifyReporter = (...args) => {
+    if (isCurrent()) report(...args);
+  };
+  void resolveProfile(entry.userId, {}, isCurrent, scopedReport, resumed, true);
+}
+
+export default { enrich, initialize };