@base44-preview/sdk 0.8.6-pr.57.d5771ed → 0.8.6-pr.57.faeb046

package/dist/client.js

@@ -99,13 +99,14 @@ export function createClient(config) {
         token: serviceToken,
         interceptResponses: false,
     });
+    const userAuthModule = createAuthModule(axiosClient, functionsAxiosClient, appId, {
+        appBaseUrl,
+        serverUrl,
+    });
     const userModules = {
         entities: createEntitiesModule(axiosClient, appId),
         integrations: createIntegrationsModule(axiosClient, appId),
-        auth: createAuthModule(axiosClient, functionsAxiosClient, appId, {
-            appBaseUrl,
-            serverUrl,
-        }),
+        auth: userAuthModule,
         functions: createFunctionsModule(functionsAxiosClient, appId),
         agents: createAgentsModule({
             axios: axiosClient,
@@ -118,8 +119,9 @@ export function createClient(config) {
         users: createUsersModule(axiosClient, appId),
         analytics: createAnalyticsModule({
             axiosClient,
+            serverUrl,
             appId,
-            options: options === null || options === void 0 ? void 0 : options.analytics,
+            userAuthModule,
         }),
         cleanup: () => {
             if (socket) {

package/dist/client.types.d.ts

@@ -6,7 +6,6 @@ import type { ConnectorsModule } from "./modules/connectors.types.js";
 import type { FunctionsModule } from "./modules/functions.types.js";
 import type { AgentsModule } from "./modules/agents.types.js";
 import type { AppLogsModule } from "./modules/app-logs.types.js";
-import type { AnalyticsModuleOptions } from "./modules/analytics.types.js";
 /**
  * Options for creating a Base44 client.
  */
@@ -15,7 +14,6 @@ export interface CreateClientOptions {
      * Optional error handler that will be called whenever an API error occurs.
      */
     onError?: (error: Error) => void;
-    analytics?: AnalyticsModuleOptions;
 }
 /**
  * Configuration for creating a Base44 client.

package/dist/modules/analytics.d.ts

@@ -1,10 +1,13 @@
 import { AxiosInstance } from "axios";
 import { TrackEventParams, AnalyticsModuleOptions } from "./analytics.types";
+import type { AuthModule } from "./auth.types";
 export interface AnalyticsModuleArgs {
     axiosClient: AxiosInstance;
+    serverUrl: string;
     appId: string;
-    options?: AnalyticsModuleOptions;
+    userAuthModule: AuthModule;
 }
-export declare const createAnalyticsModule: ({ axiosClient, appId, options, }: AnalyticsModuleArgs) => {
+export declare const createAnalyticsModule: ({ axiosClient, serverUrl, appId, userAuthModule, }: AnalyticsModuleArgs) => {
     track: (params: TrackEventParams) => void;
 };
+export declare function getAnalyticsModuleOptionsFromUrlParams(): AnalyticsModuleOptions | undefined;

package/dist/modules/analytics.js

@@ -1,16 +1,30 @@
-import { getSharedInstance, getSharedInstanceRefCount, } from "../utils/singleton";
+import { getSharedInstance, } from "../utils/singleton";
+///////////////////////////////////////////////
+//// shared queue for analytics events     ////
+///////////////////////////////////////////////
 const ANALYTICS_SHARED_STATE_NAME = "analytics";
 // shared state//
 const analyticsSharedState = getSharedInstance(ANALYTICS_SHARED_STATE_NAME, () => ({
     requestsQueue: [],
+    isProcessing: false,
 }));
-export const createAnalyticsModule = ({ axiosClient, appId, options, }) => {
+export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthModule, }) => {
+    var _a;
     // prevent overflow of events //
-    const MAX_QUEUE_SIZE = 1000;
-    const isEnabled = (options === null || options === void 0 ? void 0 : options.enabled) !== false;
+    const { enabled = true, maxQueueSize = 1000, throttleTime = 1000, batchSize = 30, } = (_a = getAnalyticsModuleOptionsFromUrlParams()) !== null && _a !== void 0 ? _a : {};
+    const trackBatchUrl = `${serverUrl}/api/apps/${appId}/analytics/track/batch`;
+    let sessionContext = null;
+    const getSessionContext = async () => {
+        if (sessionContext)
+            return sessionContext;
+        const user = await userAuthModule.me();
+        sessionContext = {
+            user_id: user.id,
+        };
+        return sessionContext;
+    };
     const track = (params) => {
-        if (!isEnabled ||
-            analyticsSharedState.requestsQueue.length >= MAX_QUEUE_SIZE) {
+        if (!enabled || analyticsSharedState.requestsQueue.length >= maxQueueSize) {
             return;
         }
         const intrinsicData = getEventIntrinsicData();
@@ -19,27 +33,58 @@ export const createAnalyticsModule = ({ axiosClient, appId, options, }) => {
             ...intrinsicData,
         });
     };
-    const flush = async (eventsData) => {
-        const apiEvents = eventsData.map(transformEventDataToApiRequestData);
+    const batchRequestFallback = async (events) => {
         await axiosClient.request({
             method: "POST",
             url: `/apps/${appId}/analytics/track/batch`,
-            data: { events: apiEvents },
+            data: { events },
         });
     };
+    const flush = async (eventsData) => {
+        const sessionContext_ = sessionContext !== null && sessionContext !== void 0 ? sessionContext : (await getSessionContext());
+        const events = eventsData.map(transformEventDataToApiRequestData(sessionContext_));
+        const beaconPayload = JSON.stringify({ events });
+        if (typeof navigator === "undefined" ||
+            beaconPayload.length > 60000 ||
+            !navigator.sendBeacon(trackBatchUrl, beaconPayload)) {
+            // beacon didn't work, fallback to axios
+            await batchRequestFallback(events);
+        }
+    };
+    if (typeof window !== "undefined" && enabled) {
+        window.addEventListener("visibilitychange", () => {
+            if (document.visibilityState === "hidden") {
+                analyticsSharedState.isProcessing = false;
+                //  flush entire queue on visibility change and hope for the best //
+                const eventsData = analyticsSharedState.requestsQueue.splice(0);
+                flush(eventsData);
+            }
+            else if (document.visibilityState === "visible") {
+                startAnalyticsProcessor(flush, {
+                    throttleTime,
+                    batchSize,
+                });
+            }
+        });
+    }
     // start analytics processor only if it's the first instance and analytics is enabled //
-    if (getSharedInstanceRefCount(ANALYTICS_SHARED_STATE_NAME) <= 1 &&
-        isEnabled) {
-        startAnalyticsProcessor(flush, options === null || options === void 0 ? void 0 : options.trackService);
+    if (enabled) {
+        startAnalyticsProcessor(flush, {
+            throttleTime,
+            batchSize,
+        });
     }
     return {
         track,
     };
 };
 async function startAnalyticsProcessor(handleTrack, options) {
+    if (analyticsSharedState.isProcessing) {
+        return;
+    }
+    analyticsSharedState.isProcessing = true;
     const { throttleTime = 1000, batchSize = 30 } = options !== null && options !== void 0 ? options : {};
-    while (true) {
-        await new Promise((resolve) => setTimeout(resolve, throttleTime));
+    while (analyticsSharedState.isProcessing) {
         const requests = analyticsSharedState.requestsQueue.splice(0, batchSize);
         if (requests.length > 0) {
             try {
@@ -50,19 +95,33 @@ async function startAnalyticsProcessor(handleTrack, options) {
                 console.error("Error processing analytics request:", error);
             }
         }
+        await new Promise((resolve) => setTimeout(resolve, throttleTime));
     }
 }
 function getEventIntrinsicData() {
     return {
         timestamp: new Date().toISOString(),
-        pageUrl: typeof window !== "undefined" ? window.location.href : null,
+        pageUrl: typeof window !== "undefined" ? window.location.pathname : null,
     };
 }
-function transformEventDataToApiRequestData(eventData) {
-    return {
+function transformEventDataToApiRequestData(sessionContext) {
+    return (eventData) => ({
         event_name: eventData.eventName,
         properties: eventData.properties,
         timestamp: eventData.timestamp,
         page_url: eventData.pageUrl,
-    };
+        ...sessionContext,
+    });
+}
+export function getAnalyticsModuleOptionsFromUrlParams() {
+    const urlParams = new URLSearchParams(window.location.search);
+    const jsonString = urlParams.get("analytics");
+    if (!jsonString)
+        return undefined;
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (_a) {
+        return undefined;
+    }
 }

package/dist/modules/analytics.types.d.ts

@@ -13,12 +13,15 @@ export type TrackEventData = {
     properties?: TrackEventProperties;
     eventName: string;
 } & TrackEventIntrinsicData;
+export type SessionContext = {
+    user_id?: string | null;
+};
 export type AnalyticsApiRequestData = {
     event_name: string;
     properties?: TrackEventProperties;
     timestamp?: string;
     page_url?: string | null;
-};
+} & SessionContext;
 export type AnalyticsApiBatchRequest = {
     method: "POST";
     url: `/apps/${string}/analytics/track/batch`;
@@ -28,8 +31,7 @@ export type AnalyticsApiBatchRequest = {
 };
 export type AnalyticsModuleOptions = {
     enabled?: boolean;
-    trackService?: {
-        throttleTime: number;
-        batchSize: number;
-    };
+    maxQueueSize?: number;
+    throttleTime?: number;
+    batchSize?: number;
 };

package/dist/utils/singleton.js

@@ -5,8 +5,9 @@ export function getSharedInstance(name, factory) {
         windowObj.base44 = {};
     }
     if (!windowObj.base44[name]) {
-        windowObj.base44[name] = { instance: factory(), _refCount: 1 };
+        windowObj.base44[name] = { instance: factory(), _refCount: 0 };
     }
+    windowObj.base44[name]._refCount++;
     return windowObj.base44[name].instance;
 }
 export function getSharedInstanceRefCount(name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.6-pr.57.d5771ed",
+  "version": "0.8.6-pr.57.faeb046",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",