@base44-preview/sdk 0.8.6-pr.58.9363801 → 0.8.7-pr.59.f9ae6aa

package/dist/client.js

@@ -10,6 +10,7 @@ import { createAgentsModule } from "./modules/agents.js";
 import { createAppLogsModule } from "./modules/app-logs.js";
 import { createUsersModule } from "./modules/users.js";
 import { RoomsSocket } from "./utils/socket-utils.js";
+import { createAnalyticsModule } from "./modules/analytics.js";
 /**
  * Creates a Base44 client.
  *
@@ -98,17 +99,14 @@ export function createClient(config) {
         token: serviceToken,
         interceptResponses: false,
     });
+    const userAuthModule = createAuthModule(axiosClient, functionsAxiosClient, appId, {
+        appBaseUrl,
+        serverUrl,
+    });
     const userModules = {
-        entities: createEntitiesModule({
-            axios: axiosClient,
-            appId,
-            getSocket,
-        }),
+        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,
@@ -119,18 +117,21 @@ export function createClient(config) {
         }),
         appLogs: createAppLogsModule(axiosClient, appId),
         users: createUsersModule(axiosClient, appId),
+        analytics: createAnalyticsModule({
+            axiosClient,
+            serverUrl,
+            appId,
+            userAuthModule,
+        }),
         cleanup: () => {
+            userModules.analytics.cleanup();
             if (socket) {
                 socket.disconnect();
             }
         },
     };
     const serviceRoleModules = {
-        entities: createEntitiesModule({
-            axios: serviceRoleAxiosClient,
-            appId,
-            getSocket,
-        }),
+        entities: createEntitiesModule(serviceRoleAxiosClient, appId),
         integrations: createIntegrationsModule(serviceRoleAxiosClient, appId),
         sso: createSsoModule(serviceRoleAxiosClient, appId, token),
         connectors: createConnectorsModule(serviceRoleAxiosClient, appId),

package/dist/client.types.d.ts

@@ -6,6 +6,7 @@ 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 { AnalyticsModule } from "./modules/analytics.types.js";
 /**
  * Options for creating a Base44 client.
  */
@@ -82,6 +83,8 @@ export interface Base44Client {
     agents: AgentsModule;
     /** {@link AppLogsModule | App logs module} for tracking app usage. */
     appLogs: AppLogsModule;
+    /** {@link AnalyticsModule | Analytics module} for tracking app usage. */
+    analytics: AnalyticsModule;
     /** Cleanup function to disconnect WebSocket connections. Call when you're done with the client. */
     cleanup: () => void;
     /**

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl } from
 export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
 export type { Base44Client, CreateClientConfig, CreateClientOptions, Base44ErrorJSON, };
 export * from "./types.js";
-export type { EntitiesModule, EntityHandler, RealtimeEventType, RealtimeEvent, RealtimeCallback, SubscribeOptions, Subscription, } from "./modules/entities.types.js";
+export type { EntitiesModule, EntityHandler, } from "./modules/entities.types.js";
 export type { AuthModule, LoginResponse, RegisterParams, VerifyOtpParams, ChangePasswordParams, ResetPasswordParams, User, } from "./modules/auth.types.js";
 export type { IntegrationsModule, IntegrationPackage, IntegrationEndpointFunction, CoreIntegrations, InvokeLLMParams, GenerateImageParams, GenerateImageResult, UploadFileParams, UploadFileResult, SendEmailParams, SendEmailResult, ExtractDataFromUploadedFileParams, ExtractDataFromUploadedFileResult, UploadPrivateFileParams, UploadPrivateFileResult, CreateFileSignedUrlParams, CreateFileSignedUrlResult, } from "./modules/integrations.types.js";
 export type { FunctionsModule } from "./modules/functions.types.js";

package/dist/modules/analytics.d.ts

@@ -0,0 +1,18 @@
+import { AxiosInstance } from "axios";
+import { TrackEventParams, AnalyticsModuleOptions } from "./analytics.types";
+import type { AuthModule } from "./auth.types";
+export declare const USER_HEARTBEAT_EVENT_NAME = "__user_heartbeat_event__";
+export declare const ANALYTICS_CONFIG_URL_PARAM_KEY = "analytics-disable";
+export declare const ANALYTICS_SESSION_ID_LOCAL_STORAGE_KEY = "base44_analytics_session_id";
+export interface AnalyticsModuleArgs {
+    axiosClient: AxiosInstance;
+    serverUrl: string;
+    appId: string;
+    userAuthModule: AuthModule;
+}
+export declare const createAnalyticsModule: ({ axiosClient, serverUrl, appId, userAuthModule, }: AnalyticsModuleArgs) => {
+    track: (params: TrackEventParams) => void;
+    cleanup: () => void;
+};
+export declare function getAnalyticsConfigFromUrlParams(): AnalyticsModuleOptions | undefined;
+export declare function getAnalyticsSessionId(): string;

package/dist/modules/analytics.js

@@ -0,0 +1,222 @@
+import { getSharedInstance } from "../utils/sharedInstance";
+import { generateUuid } from "../utils/common";
+export const USER_HEARTBEAT_EVENT_NAME = "__user_heartbeat_event__";
+export const ANALYTICS_CONFIG_URL_PARAM_KEY = "analytics-disable";
+export const ANALYTICS_SESSION_ID_LOCAL_STORAGE_KEY = "base44_analytics_session_id";
+const defaultConfiguration = {
+    enabled: true,
+    maxQueueSize: 1000,
+    throttleTime: 1000,
+    batchSize: 30,
+    heartBeatInterval: 60 * 1000,
+};
+///////////////////////////////////////////////
+//// shared queue for analytics events     ////
+///////////////////////////////////////////////
+const ANALYTICS_SHARED_STATE_NAME = "analytics";
+// shared state//
+const analyticsSharedState = getSharedInstance(ANALYTICS_SHARED_STATE_NAME, () => ({
+    requestsQueue: [],
+    isProcessing: false,
+    isHeartBeatProcessing: false,
+    sessionContext: null,
+    config: {
+        ...defaultConfiguration,
+        ...getAnalyticsConfigFromUrlParams(),
+    },
+}));
+export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthModule, }) => {
+    var _a;
+    // prevent overflow of events //
+    const { maxQueueSize, throttleTime, batchSize } = analyticsSharedState.config;
+    if (!((_a = analyticsSharedState.config) === null || _a === void 0 ? void 0 : _a.enabled)) {
+        return {
+            track: () => { },
+            cleanup: () => { },
+        };
+    }
+    let clearHeartBeatProcessor = undefined;
+    const trackBatchUrl = `${serverUrl}/api/apps/${appId}/analytics/track/batch`;
+    const batchRequestFallback = async (events) => {
+        await axiosClient.request({
+            method: "POST",
+            url: `/apps/${appId}/analytics/track/batch`,
+            data: { events },
+        });
+    };
+    const beaconRequest = async (events) => {
+        const beaconPayload = JSON.stringify({ events });
+        try {
+            const blob = new Blob([beaconPayload], { type: "application/json" });
+            return (typeof navigator === "undefined" ||
+                beaconPayload.length > 60000 ||
+                !navigator.sendBeacon(trackBatchUrl, blob));
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    const flush = async (eventsData) => {
+        const sessionContext_ = await getSessionContext(userAuthModule);
+        const events = eventsData.map(transformEventDataToApiRequestData(sessionContext_));
+        if (!(await beaconRequest(events))) {
+            return batchRequestFallback(events);
+        }
+    };
+    const startProcessing = () => {
+        startAnalyticsProcessor(flush, {
+            throttleTime,
+            batchSize,
+        });
+    };
+    const track = (params) => {
+        if (analyticsSharedState.requestsQueue.length >= maxQueueSize) {
+            return;
+        }
+        const intrinsicData = getEventIntrinsicData();
+        analyticsSharedState.requestsQueue.push({
+            ...params,
+            ...intrinsicData,
+        });
+        startProcessing();
+    };
+    const onDocVisible = () => {
+        startAnalyticsProcessor(flush, {
+            throttleTime,
+            batchSize,
+        });
+        clearHeartBeatProcessor = startHeartBeatProcessor(track);
+    };
+    const onDocHidden = () => {
+        stopAnalyticsProcessor();
+        //  flush entire queue on visibility change and hope for the best //
+        const eventsData = analyticsSharedState.requestsQueue.splice(0);
+        flush(eventsData);
+        clearHeartBeatProcessor === null || clearHeartBeatProcessor === void 0 ? void 0 : clearHeartBeatProcessor();
+    };
+    const onVisibilityChange = () => {
+        if (typeof window === "undefined")
+            return;
+        if (document.visibilityState === "hidden") {
+            onDocHidden();
+        }
+        else if (document.visibilityState === "visible") {
+            onDocVisible();
+        }
+    };
+    const cleanup = () => {
+        stopAnalyticsProcessor();
+        clearHeartBeatProcessor === null || clearHeartBeatProcessor === void 0 ? void 0 : clearHeartBeatProcessor();
+        if (typeof window !== "undefined") {
+            window.removeEventListener("visibilitychange", onVisibilityChange);
+        }
+    };
+    // start the flusing process ///
+    startProcessing();
+    // start the heart beat processor //
+    clearHeartBeatProcessor = startHeartBeatProcessor(track);
+    // start the visibility change listener //
+    if (typeof window !== "undefined") {
+        window.addEventListener("visibilitychange", onVisibilityChange);
+    }
+    return {
+        track,
+        cleanup,
+    };
+};
+function stopAnalyticsProcessor() {
+    analyticsSharedState.isProcessing = false;
+}
+async function startAnalyticsProcessor(handleTrack, options) {
+    if (analyticsSharedState.isProcessing) {
+        // only one instance of the analytics processor can be running at a time //
+        return;
+    }
+    analyticsSharedState.isProcessing = true;
+    const { throttleTime = 1000, batchSize = 30 } = options !== null && options !== void 0 ? options : {};
+    while (analyticsSharedState.isProcessing &&
+        analyticsSharedState.requestsQueue.length > 0) {
+        const requests = analyticsSharedState.requestsQueue.splice(0, batchSize);
+        requests.length && (await handleTrack(requests));
+        await new Promise((resolve) => setTimeout(resolve, throttleTime));
+    }
+    analyticsSharedState.isProcessing = false;
+}
+function startHeartBeatProcessor(track) {
+    var _a;
+    if (analyticsSharedState.isHeartBeatProcessing ||
+        ((_a = analyticsSharedState.config.heartBeatInterval) !== null && _a !== void 0 ? _a : 0) < 10) {
+        return () => { };
+    }
+    analyticsSharedState.isHeartBeatProcessing = true;
+    const interval = setInterval(() => {
+        track({ eventName: USER_HEARTBEAT_EVENT_NAME });
+    }, analyticsSharedState.config.heartBeatInterval);
+    return () => {
+        clearInterval(interval);
+        analyticsSharedState.isHeartBeatProcessing = false;
+    };
+}
+function getEventIntrinsicData() {
+    return {
+        timestamp: new Date().toISOString(),
+        pageUrl: typeof window !== "undefined" ? window.location.pathname : null,
+    };
+}
+function transformEventDataToApiRequestData(sessionContext) {
+    return (eventData) => ({
+        event_name: eventData.eventName,
+        properties: eventData.properties,
+        timestamp: eventData.timestamp,
+        page_url: eventData.pageUrl,
+        ...sessionContext,
+    });
+}
+let sessionContextPromise = null;
+async function getSessionContext(userAuthModule) {
+    if (!analyticsSharedState.sessionContext) {
+        if (!sessionContextPromise) {
+            const sessionId = getAnalyticsSessionId();
+            sessionContextPromise = userAuthModule
+                .me()
+                .then((user) => ({
+                user_id: user.id,
+                session_id: sessionId,
+            }))
+                .catch(() => ({
+                user_id: null,
+                session_id: sessionId,
+            }));
+        }
+        analyticsSharedState.sessionContext = await sessionContextPromise;
+    }
+    return analyticsSharedState.sessionContext;
+}
+export function getAnalyticsConfigFromUrlParams() {
+    if (typeof window === "undefined")
+        return undefined;
+    const urlParams = new URLSearchParams(window.location.search);
+    const analyticsDisable = urlParams.get(ANALYTICS_CONFIG_URL_PARAM_KEY);
+    const newUrlParams = new URLSearchParams(window.location.search);
+    newUrlParams.delete(ANALYTICS_CONFIG_URL_PARAM_KEY);
+    const newUrl = `${window.location.pathname}?${newUrlParams.toString()}`;
+    window.history.replaceState({}, document.title, newUrl);
+    return analyticsDisable === "true" ? { enabled: false } : undefined;
+}
+export function getAnalyticsSessionId() {
+    if (typeof window === "undefined") {
+        return generateUuid();
+    }
+    try {
+        const sessionId = localStorage.getItem(ANALYTICS_SESSION_ID_LOCAL_STORAGE_KEY);
+        if (!sessionId) {
+            const newSessionId = generateUuid();
+            localStorage.setItem(ANALYTICS_SESSION_ID_LOCAL_STORAGE_KEY, newSessionId);
+            return newSessionId;
+        }
+        return sessionId;
+    }
+    catch (_a) {
+        return generateUuid();
+    }
+}

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

@@ -0,0 +1,42 @@
+export type TrackEventProperties = {
+    [key: string]: string | number | boolean | null | undefined;
+};
+export type TrackEventParams = {
+    eventName: string;
+    properties?: TrackEventProperties;
+};
+export type TrackEventIntrinsicData = {
+    timestamp: string;
+    pageUrl?: string | null;
+};
+export type TrackEventData = {
+    properties?: TrackEventProperties;
+    eventName: string;
+} & TrackEventIntrinsicData;
+export type SessionContext = {
+    user_id?: string | null;
+    session_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`;
+    data: {
+        events: AnalyticsApiRequestData[];
+    };
+};
+export type AnalyticsModuleOptions = {
+    enabled?: boolean;
+    maxQueueSize?: number;
+    throttleTime?: number;
+    batchSize?: number;
+    heartBeatInterval?: number;
+};
+export type AnalyticsModule = {
+    track: (params: TrackEventParams) => void;
+};

package/dist/modules/analytics.types.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/entities.d.ts

@@ -1,23 +1,5 @@
 import { AxiosInstance } from "axios";
 import { EntitiesModule } from "./entities.types";
-import { RoomsSocket } from "../utils/socket-utils";
-/**
- * Configuration for the entities module.
- * @internal
- */
-export interface EntitiesModuleConfig {
-    axios: AxiosInstance;
-    appId: string;
-    getSocket: () => ReturnType<typeof RoomsSocket>;
-}
-/**
- * Creates the entities module for the Base44 SDK.
- *
- * @param config - Configuration object containing axios, appId, and getSocket
- * @returns Entities module with dynamic entity access
- * @internal
- */
-export declare function createEntitiesModule(config: EntitiesModuleConfig): EntitiesModule;
 /**
  * Creates the entities module for the Base44 SDK.
  *
@@ -25,6 +7,5 @@ export declare function createEntitiesModule(config: EntitiesModuleConfig): Enti
  * @param appId - Application ID
  * @returns Entities module with dynamic entity access
  * @internal
- * @deprecated Use the config object overload instead
  */
 export declare function createEntitiesModule(axios: AxiosInstance, appId: string): EntitiesModule;

package/dist/modules/entities.js

@@ -1,15 +1,12 @@
-export function createEntitiesModule(configOrAxios, appIdArg) {
-    // Handle both old and new signatures for backwards compatibility
-    const config = "axios" in configOrAxios
-        ? configOrAxios
-        : {
-            axios: configOrAxios,
-            appId: appIdArg,
-            getSocket: () => {
-                throw new Error("Realtime subscriptions are not available. Please update your client configuration.");
-            },
-        };
-    const { axios, appId, getSocket } = config;
+/**
+ * Creates the entities module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @returns Entities module with dynamic entity access
+ * @internal
+ */
+export function createEntitiesModule(axios, appId) {
     // Using Proxy to dynamically handle entity names
     return new Proxy({}, {
         get(target, entityName) {
@@ -20,59 +17,20 @@ export function createEntitiesModule(configOrAxios, appIdArg) {
                 return undefined;
             }
             // Create entity handler
-            return createEntityHandler(axios, appId, entityName, getSocket);
+            return createEntityHandler(axios, appId, entityName);
         },
     });
 }
-/**
- * Creates a stable hash from a query object for room naming.
- * @internal
- */
-function hashQuery(query) {
-    const sortedKeys = Object.keys(query).sort();
-    const normalized = sortedKeys
-        .map((k) => `${k}:${JSON.stringify(query[k])}`)
-        .join("|");
-    // Simple hash function
-    let hash = 0;
-    for (let i = 0; i < normalized.length; i++) {
-        const char = normalized.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash; // Convert to 32bit integer
-    }
-    return Math.abs(hash).toString(36);
-}
-/**
- * Parses the realtime message data and extracts event information.
- * @internal
- */
-function parseRealtimeMessage(dataStr) {
-    var _a;
-    try {
-        const parsed = JSON.parse(dataStr);
-        return {
-            type: parsed.type,
-            data: parsed.data,
-            id: parsed.id || ((_a = parsed.data) === null || _a === void 0 ? void 0 : _a.id),
-            timestamp: parsed.timestamp || new Date().toISOString(),
-            previousData: parsed.previousData,
-        };
-    }
-    catch (_b) {
-        return null;
-    }
-}
 /**
  * Creates a handler for a specific entity.
  *
  * @param axios - Axios instance
  * @param appId - Application ID
  * @param entityName - Entity name
- * @param getSocket - Function to get the socket instance
  * @returns Entity handler with CRUD methods
  * @internal
  */
-function createEntityHandler(axios, appId, entityName, getSocket) {
+function createEntityHandler(axios, appId, entityName) {
     const baseURL = `/apps/${appId}/entities/${entityName}`;
     return {
         // List entities with optional pagination and sorting
@@ -137,52 +95,5 @@ function createEntityHandler(axios, appId, entityName, getSocket) {
                 },
             });
         },
-        // Subscribe to realtime updates
-        subscribe(callbackOrIdOrQuery, callbackOrOptions, optionsArg) {
-            let room;
-            let callback;
-            let options;
-            // Parse overloaded arguments
-            if (typeof callbackOrIdOrQuery === "function") {
-                // subscribe(callback, options?)
-                room = `entities:${appId}:${entityName}`;
-                callback = callbackOrIdOrQuery;
-                options = callbackOrOptions;
-            }
-            else if (typeof callbackOrIdOrQuery === "string") {
-                // subscribe(id, callback, options?)
-                room = `entities:${appId}:${entityName}:${callbackOrIdOrQuery}`;
-                callback = callbackOrOptions;
-                options = optionsArg;
-            }
-            else {
-                // subscribe(query, callback, options?)
-                const queryHash = hashQuery(callbackOrIdOrQuery);
-                room = `entities:${appId}:${entityName}:query:${queryHash}`;
-                callback = callbackOrOptions;
-                options = optionsArg;
-            }
-            const eventFilter = options === null || options === void 0 ? void 0 : options.events;
-            // Get the socket and subscribe to the room
-            const socket = getSocket();
-            const unsubscribe = socket.subscribeToRoom(room, {
-                update_model: (msg) => {
-                    // Only process messages for our room
-                    if (msg.room !== room)
-                        return;
-                    const event = parseRealtimeMessage(msg.data);
-                    if (!event)
-                        return;
-                    // Apply event type filter if specified
-                    if (eventFilter && !eventFilter.includes(event.type)) {
-                        return;
-                    }
-                    callback(event);
-                },
-            });
-            return {
-                unsubscribe,
-            };
-        },
     };
 }

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

@@ -1,40 +1,3 @@
-/**
- * Event types for realtime entity updates.
- */
-export type RealtimeEventType = "create" | "update" | "delete";
-/**
- * Payload received when a realtime event occurs.
- */
-export interface RealtimeEvent<T = Record<string, any>> {
-    /** The type of change that occurred */
-    type: RealtimeEventType;
-    /** The entity data (new/updated for create/update, previous for delete) */
-    data: T;
-    /** The unique identifier of the affected entity */
-    id: string;
-    /** ISO 8601 timestamp of when the event occurred */
-    timestamp: string;
-    /** For update events, contains the previous data before the change */
-    previousData?: T;
-}
-/**
- * Callback function invoked when a realtime event occurs.
- */
-export type RealtimeCallback<T = Record<string, any>> = (event: RealtimeEvent<T>) => void;
-/**
- * Options for subscribing to realtime updates.
- */
-export interface SubscribeOptions {
-    /** Filter events by type. Defaults to all types. */
-    events?: RealtimeEventType[];
-}
-/**
- * Handle returned from subscribe, used to unsubscribe.
- */
-export interface Subscription {
-    /** Stops listening to updates and cleans up the subscription. */
-    unsubscribe: () => void;
-}
 /**
  * Entity handler providing CRUD operations for a specific entity type.
  *
@@ -279,93 +242,6 @@ export interface EntityHandler {
      * ```
      */
     importEntities(file: File): Promise<any>;
-    /**
-     * Subscribes to realtime updates for all records of this entity type.
-     *
-     * Receives notifications whenever any record is created, updated, or deleted.
-     *
-     * @param callback - Function called when an entity changes.
-     * @param options - Optional configuration for filtering events.
-     * @returns Subscription handle with an unsubscribe method.
-     *
-     * @example
-     * ```typescript
-     * // Subscribe to all Task changes
-     * const subscription = base44.entities.Task.subscribe((event) => {
-     *   console.log(`Task ${event.id} was ${event.type}d:`, event.data);
-     * });
-     *
-     * // Later, unsubscribe
-     * subscription.unsubscribe();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Subscribe only to create events
-     * const subscription = base44.entities.Task.subscribe(
-     *   (event) => console.log("New task:", event.data),
-     *   { events: ["create"] }
-     * );
-     * ```
-     */
-    subscribe(callback: RealtimeCallback, options?: SubscribeOptions): Subscription;
-    /**
-     * Subscribes to realtime updates for a specific entity record.
-     *
-     * Receives notifications when the specified record is updated or deleted.
-     *
-     * @param id - The unique identifier of the record to watch.
-     * @param callback - Function called when the entity changes.
-     * @param options - Optional configuration for filtering events.
-     * @returns Subscription handle with an unsubscribe method.
-     *
-     * @example
-     * ```typescript
-     * // Subscribe to a specific task
-     * const subscription = base44.entities.Task.subscribe("task-123", (event) => {
-     *   if (event.type === "update") {
-     *     console.log("Task updated:", event.data);
-     *   } else if (event.type === "delete") {
-     *     console.log("Task was deleted");
-     *   }
-     * });
-     * ```
-     */
-    subscribe(id: string, callback: RealtimeCallback, options?: SubscribeOptions): Subscription;
-    /**
-     * Subscribes to realtime updates for records matching a query.
-     *
-     * Receives notifications for records that match the specified criteria.
-     * Includes create events when new records match the query, update events
-     * when matching records change, and delete events when matching records
-     * are removed.
-     *
-     * @param query - Query object with field-value pairs to filter records.
-     * @param callback - Function called when a matching entity changes.
-     * @param options - Optional configuration for filtering events.
-     * @returns Subscription handle with an unsubscribe method.
-     *
-     * @example
-     * ```typescript
-     * // Subscribe to all completed tasks
-     * const subscription = base44.entities.Task.subscribe(
-     *   { isCompleted: true },
-     *   (event) => {
-     *     console.log(`Completed task ${event.type}:`, event.data);
-     *   }
-     * );
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Subscribe to high-priority active tasks
-     * const subscription = base44.entities.Task.subscribe(
-     *   { priority: "high", status: "active" },
-     *   (event) => console.log("High priority task changed:", event.data)
-     * );
-     * ```
-     */
-    subscribe(query: Record<string, any>, callback: RealtimeCallback, options?: SubscribeOptions): Subscription;
 }
 /**
  * Entities module for managing app data.

package/dist/modules/types.d.ts

@@ -1,3 +1,4 @@
 export * from "./app.types.js";
 export * from "./agents.types.js";
 export * from "./connectors.types.js";
+export * from "./analytics.types.js";

package/dist/modules/types.js

@@ -1,3 +1,4 @@
 export * from "./app.types.js";
 export * from "./agents.types.js";
 export * from "./connectors.types.js";
+export * from "./analytics.types.js";

package/dist/utils/common.d.ts

@@ -1,2 +1,3 @@
 export declare const isNode: boolean;
 export declare const isInIFrame: boolean;
+export declare const generateUuid: () => string;

package/dist/utils/common.js

@@ -1,2 +1,6 @@
 export const isNode = typeof window === "undefined";
 export const isInIFrame = !isNode && window.self !== window.top;
+export const generateUuid = () => {
+    return (Math.random().toString(36).substring(2, 15) +
+        Math.random().toString(36).substring(2, 15));
+};

package/dist/utils/sharedInstance.d.ts

@@ -0,0 +1 @@
+export declare function getSharedInstance<T>(name: string, factory: () => T): T;

package/dist/utils/sharedInstance.js

@@ -0,0 +1,15 @@
+const windowObj = typeof window !== "undefined"
+    ? window
+    : { base44SharedInstances: {} };
+// Singleton (shared between sdk instances)//
+export function getSharedInstance(name, factory) {
+    if (!windowObj.base44SharedInstances) {
+        windowObj.base44SharedInstances = {};
+    }
+    if (!windowObj.base44SharedInstances[name]) {
+        windowObj.base44SharedInstances[name] = {
+            instance: factory(),
+        };
+    }
+    return windowObj.base44SharedInstances[name].instance;
+}

package/package.json

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