feat(sdk) : added framework support and sdk support

app/analytics-worker/analyticsWorker.ts

@@ -1,7 +1,17 @@
 import { Worker, Queue } from "bullmq";
-import { redis } from "@glimpse/db/redis";
 import { prisma } from "@glimpse/db/client";
 
+
+/**
+ * What to precompute for analytics:
+ * 
+ * AnalyticsSession
+ * DailyEventAggregate
+ * DailyPageAnalytics
+ * DailyUserAnalytics
+ * AnalyticsCheckpoint
+ */
+
 const redisPort = process.env.REDIS_PORT
     ? Number(process.env.REDIS_PORT)
     : 6379;
@@ -23,7 +33,18 @@ const analyticsWorker = new Worker(
         switch (job.name) {
             case "analytics-job":
                 const { data } = job;
-                // Process the analytics data                
+
+                // AnalyticsSession computation
+
+                const analyticsSession = {
+                    projectId: data.projectId,
+                    sessionId: data.sessionId,
+
+
+                    createdAt : new Date(),
+                    updatedAt : new Date(), 
+                }
+
                 break;
             default:
                 console.warn(`Unknown job type: ${job.name}`);

packages/analytics-web/core/config.js

@@ -0,0 +1,87 @@
+/**
+ * SDK Configuration
+ * Supports both script tag attributes and programmatic initialization
+ */
+
+let config = {
+    projectId: undefined,
+    endpoint: 'http://localhost:3000/event',
+    autoTrack: true,
+    debug: false,
+    trackPageViews: true,
+    trackWebVitals: true,
+    trackEngagement: true,
+    trackErrors: true,
+    sessionTimeout: 30 * 60 * 1000, // 30 minutes
+};
+
+let initialized = false;
+
+/**
+ * Check if running in browser
+ */
+export function isBrowser() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+
+/**
+ * Get current config
+ */
+export function getConfig() {
+    return { ...config };
+}
+
+/**
+ * Initialize the SDK programmatically
+ * Use this for React, Vue, Next.js, etc.
+ */
+export function init(options = {}) {
+    if (!isBrowser()) {
+        console.warn('GlimpseTracker: Cannot initialize on server. Use in useEffect/onMounted.');
+        return false;
+    }
+
+    if (initialized && !options.force) {
+        if (config.debug) console.info('GlimpseTracker: Already initialized');
+        return true;
+    }
+
+    config = {
+        ...config,
+        ...options,
+    };
+
+    if (!config.projectId) {
+        console.warn('GlimpseTracker: projectId is required');
+        return false;
+    }
+
+    initialized = true;
+
+    // Update global tracker
+    if (window.GlimpseTracker) {
+        window.GlimpseTracker.projectId = config.projectId;
+        window.GlimpseTracker.endpoint = config.endpoint;
+        window.GlimpseTracker.debug = config.debug;
+    }
+
+    if (config.debug) {
+        console.info('GlimpseTracker: Initialized', config);
+    }
+
+    return true;
+}
+
+/**
+ * Check if SDK is initialized
+ */
+export function isInitialized() {
+    return initialized;
+}
+
+/**
+ * Reset initialization (for testing)
+ */
+export function resetInit() {
+    initialized = false;
+}

packages/analytics-web/core/event.js

@@ -1,43 +1,78 @@
+import { getAnonymousId, getUserId, getTraits } from './identity.js';
+
 // Track previous path within the session
-let prevPath = sessionStorage.getItem('analytics_prev_path') || undefined;
+let prevPath = sessionStorage.getItem('glimpse_prev_path') || undefined;
 
-export function createEvent(projectId, sessionId, name, properties) {
-    const currentPath = location.pathname + location.search + location.hash;
+/**
+ * Create a fully-formed event object matching the schema
+ */
+export function createEvent(projectId, sessionId, name, properties = {}) {
+    const currentPath = location.pathname + location.search;
 
     const evt = {
         projectId,
         event: name,
         timestamp: Date.now(),
+
+        // Identity
         sessionId,
+        anonymousId: getAnonymousId(),
+        userId: getUserId(),
+        traits: getTraits(),
+
+        // Event data
         properties: properties || {},
+
+        // Context
         context: {
+            // Page info
             url: window.location.href,
-            referrer: document.referrer || undefined,
             path: currentPath,
+            hash: location.hash || undefined,
             title: document.title || undefined,
+            referrer: document.referrer || undefined,
             previousPath: prevPath,
-
-            viewport: `${window.innerWidth}x${window.innerHeight}`,
+
+            // Device & viewport
+            viewport: {
+                width: window.innerWidth,
+                height: window.innerHeight
+            },
             screen: {
                 width: window.screen.width,
                 height: window.screen.height,
-                colorDepth: window.screen.colorDepth
+                colorDepth: window.screen.colorDepth,
+                pixelRatio: window.devicePixelRatio || 1
             },
-
+
+            // Browser info
             userAgent: navigator.userAgent,
             language: navigator.language,
+            languages: navigator.languages ? [...navigator.languages] : [navigator.language],
             timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-
-            connection: navigator.connection && {
+            cookiesEnabled: navigator.cookieEnabled,
+
+            // Connection info
+            connection: navigator.connection ? {
                 effectiveType: navigator.connection.effectiveType,
-                saveData: navigator.connection.saveData,
-            },  
+                downlink: navigator.connection.downlink,
+                rtt: navigator.connection.rtt,
+                saveData: navigator.connection.saveData
+            } : undefined,
+
+            // Touch capability
+            touchPoints: navigator.maxTouchPoints || 0,
+
+            // Platform hints
+            platform: navigator.userAgentData ? {
+                mobile: navigator.userAgentData.mobile,
+                platform: navigator.userAgentData.platform
+            } : undefined
         }
     };
 
     prevPath = currentPath;
-    sessionStorage.setItem('analytics_prev_path', currentPath);
+    sessionStorage.setItem('glimpse_prev_path', currentPath);
 
     return evt;
 }
-

packages/analytics-web/core/identity.js

@@ -0,0 +1,69 @@
+const ANON_ID_KEY = 'glimpse_anonymous_id';
+const USER_ID_KEY = 'glimpse_user_id';
+const TRAITS_KEY = 'glimpse_traits';
+
+/**
+ * Get or create a persistent anonymous ID
+ */
+export function getAnonymousId() {
+    let anonId = localStorage.getItem(ANON_ID_KEY);
+    if (!anonId) {
+        anonId = `anon_${crypto.randomUUID ? crypto.randomUUID() : generateUUID()}`;
+        localStorage.setItem(ANON_ID_KEY, anonId);
+    }
+    return anonId;
+}
+
+/**
+ * Get the current user ID (if identified)
+ */
+export function getUserId() {
+    return localStorage.getItem(USER_ID_KEY) || undefined;
+}
+
+/**
+ * Get stored user traits
+ */
+export function getTraits() {
+    try {
+        const stored = localStorage.getItem(TRAITS_KEY);
+        return stored ? JSON.parse(stored) : {};
+    } catch {
+        return {};
+    }
+}
+
+/**
+ * Set user identity and traits
+ */
+export function setIdentity(userId, traits = {}) {
+    if (userId) {
+        localStorage.setItem(USER_ID_KEY, userId);
+    }
+
+    const existingTraits = getTraits();
+    const mergedTraits = { ...existingTraits, ...traits };
+    localStorage.setItem(TRAITS_KEY, JSON.stringify(mergedTraits));
+
+    return { userId, traits: mergedTraits };
+}
+
+/**
+ * Reset identity (logout)
+ */
+export function resetIdentity() {
+    localStorage.removeItem(USER_ID_KEY);
+    localStorage.removeItem(TRAITS_KEY);
+    // Keep anonymous ID - regenerate on next page load if needed
+}
+
+/**
+ * Fallback UUID generator for older browsers
+ */
+function generateUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}

packages/analytics-web/core/session.js

@@ -1,9 +1,72 @@
+const SESSION_ID_KEY = 'glimpse_session_id';
+const SESSION_START_KEY = 'glimpse_session_start';
+const SESSION_LAST_ACTIVE_KEY = 'glimpse_session_last_active';
+const SESSION_TIMEOUT = 30 * 60 * 1000; // 30 minutes
+
+/**
+ * Get or create session ID
+ * Sessions expire after 30 minutes of inactivity
+ */
 export function getSessionId() {
-    let sid = sessionStorage.getItem('analytics_session_id');
+    const now = Date.now();
+    let sid = sessionStorage.getItem(SESSION_ID_KEY);
+    const lastActive = parseInt(sessionStorage.getItem(SESSION_LAST_ACTIVE_KEY) || '0', 10);
+
+    // Check if session expired
+    if (sid && lastActive && (now - lastActive > SESSION_TIMEOUT)) {
+        // Session expired, create new one
+        sid = null;
+    }
+
     if (!sid) {
-        sid = `sess_${Math.random().toString(36).substring(2, 15)}`;
-        sessionStorage.setItem('analytics_session_id', sid);
+        sid = `sess_${crypto.randomUUID ? crypto.randomUUID().slice(0, 12) : Math.random().toString(36).substring(2, 15)}`;
+        sessionStorage.setItem(SESSION_ID_KEY, sid);
+        sessionStorage.setItem(SESSION_START_KEY, now.toString());
     }
+
+    // Update last active time
+    sessionStorage.setItem(SESSION_LAST_ACTIVE_KEY, now.toString());
+
     return sid;
 }
 
+/**
+ * Check if this is a new session (first page view or after timeout)
+ */
+export function isNewSession() {
+    const sid = sessionStorage.getItem(SESSION_ID_KEY);
+    if (!sid) return true;
+
+    const lastActive = parseInt(sessionStorage.getItem(SESSION_LAST_ACTIVE_KEY) || '0', 10);
+    return lastActive && (Date.now() - lastActive > SESSION_TIMEOUT);
+}
+
+/**
+ * Get session start timestamp
+ */
+export function getSessionStart() {
+    return parseInt(sessionStorage.getItem(SESSION_START_KEY) || Date.now().toString(), 10);
+}
+
+/**
+ * Get session duration in milliseconds
+ */
+export function getSessionDuration() {
+    const start = getSessionStart();
+    return Date.now() - start;
+}
+
+/**
+ * Track page view count in session
+ */
+const PAGE_VIEW_COUNT_KEY = 'glimpse_page_view_count';
+
+export function incrementPageViewCount() {
+    const count = getPageViewCount() + 1;
+    sessionStorage.setItem(PAGE_VIEW_COUNT_KEY, count.toString());
+    return count;
+}
+
+export function getPageViewCount() {
+    return parseInt(sessionStorage.getItem(PAGE_VIEW_COUNT_KEY) || '0', 10);
+}