@databuddy/sdk 2.1.77 → 2.2.0

package/dist/node/index.mjs

@@ -0,0 +1,344 @@
+function createLogger(debug = false) {
+  try {
+    const pino = require("pino");
+    return pino({
+      level: debug ? "debug" : "info",
+      name: "databuddy"
+    });
+  } catch {
+    return createConsoleLogger(debug);
+  }
+}
+function createConsoleLogger(debug) {
+  const noop = () => {
+  };
+  return {
+    info(msg, data) {
+      if (debug) {
+        console.info(`[Databuddy] ${msg}`, data ? JSON.stringify(data) : "");
+      }
+    },
+    error(msg, data) {
+      if (debug) {
+        console.error(
+          `[Databuddy] ${msg}`,
+          data ? JSON.stringify(data) : ""
+        );
+      }
+    },
+    warn(msg, data) {
+      if (debug) {
+        console.warn(`[Databuddy] ${msg}`, data ? JSON.stringify(data) : "");
+      }
+    },
+    debug: debug ? (msg, data) => {
+      console.debug(
+        `[Databuddy] ${msg}`,
+        data ? JSON.stringify(data) : ""
+      );
+    } : noop
+  };
+}
+function createNoopLogger() {
+  const noop = () => {
+  };
+  return {
+    info: noop,
+    error: noop,
+    warn: noop,
+    debug: noop
+  };
+}
+
+class EventQueue {
+  queue = [];
+  maxSize;
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  add(event) {
+    this.queue.push(event);
+    return this.queue.length >= this.maxSize;
+  }
+  getAll() {
+    return [...this.queue];
+  }
+  clear() {
+    this.queue = [];
+  }
+  size() {
+    return this.queue.length;
+  }
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+}
+
+const DEFAULT_API_URL = "https://basket.databuddy.cc";
+const DEFAULT_BATCH_SIZE = 10;
+const DEFAULT_BATCH_TIMEOUT = 2e3;
+const DEFAULT_MAX_QUEUE_SIZE = 1e3;
+class Databuddy {
+  clientId;
+  apiUrl;
+  logger;
+  enableBatching;
+  batchSize;
+  batchTimeout;
+  queue;
+  flushTimer = null;
+  constructor(config) {
+    if (!config.clientId || typeof config.clientId !== "string") {
+      throw new Error("clientId is required and must be a string");
+    }
+    this.clientId = config.clientId.trim();
+    this.apiUrl = config.apiUrl?.trim() || DEFAULT_API_URL;
+    this.enableBatching = config.enableBatching !== false;
+    this.batchSize = Math.min(config.batchSize || DEFAULT_BATCH_SIZE, 100);
+    this.batchTimeout = config.batchTimeout || DEFAULT_BATCH_TIMEOUT;
+    this.queue = new EventQueue(config.maxQueueSize || DEFAULT_MAX_QUEUE_SIZE);
+    if (config.logger) {
+      this.logger = config.logger;
+    } else if (config.debug) {
+      this.logger = createLogger(true);
+    } else {
+      this.logger = createNoopLogger();
+    }
+    this.logger.info("Initialized", {
+      clientId: this.clientId,
+      apiUrl: this.apiUrl,
+      enableBatching: this.enableBatching,
+      batchSize: this.batchSize,
+      batchTimeout: this.batchTimeout
+    });
+  }
+  /**
+   * Track a custom event
+   * If batching is enabled, queues the event and auto-flushes when batch size is reached or timeout expires
+   * If batching is disabled, sends the event immediately
+   *
+   * @param event - Custom event data
+   * @returns Response indicating success or failure
+   *
+   * @example
+   * ```typescript
+   * await client.track({
+   *   name: 'user_signup',
+   *   properties: { plan: 'pro' }
+   * });
+   * ```
+   */
+  async track(event) {
+    if (!event.name || typeof event.name !== "string") {
+      return {
+        success: false,
+        error: "Event name is required and must be a string"
+      };
+    }
+    const batchEvent = {
+      type: "custom",
+      name: event.name,
+      eventId: event.eventId,
+      anonymousId: event.anonymousId,
+      sessionId: event.sessionId,
+      timestamp: event.timestamp,
+      properties: event.properties || null
+    };
+    if (!this.enableBatching) {
+      return this.send(batchEvent);
+    }
+    const shouldFlush = this.queue.add(batchEvent);
+    this.logger.debug("Event queued", { queueSize: this.queue.size() });
+    this.scheduleFlush();
+    if (shouldFlush || this.queue.size() >= this.batchSize) {
+      await this.flush();
+    }
+    return { success: true };
+  }
+  async send(event) {
+    try {
+      const url = `${this.apiUrl}/?client_id=${encodeURIComponent(this.clientId)}`;
+      this.logger.info("\u{1F4E4} SENDING SINGLE EVENT:", {
+        name: event.name,
+        properties: JSON.stringify(event.properties, null, 2),
+        propertiesCount: Object.keys(event.properties || {}).length
+      });
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(event)
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        this.logger.error("Request failed", {
+          status: response.status,
+          statusText: response.statusText,
+          body: errorText
+        });
+        return {
+          success: false,
+          error: `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      const data = await response.json();
+      this.logger.info("Response received", data);
+      if (data.status === "success") {
+        return {
+          success: true,
+          eventId: data.eventId
+        };
+      }
+      return {
+        success: false,
+        error: data.message || "Unknown error from server"
+      };
+    } catch (error) {
+      this.logger.error("Request error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Network request failed"
+      };
+    }
+  }
+  scheduleFlush() {
+    if (this.flushTimer) {
+      return;
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flush().catch((error) => {
+        this.logger.error("Auto-flush error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }, this.batchTimeout);
+  }
+  /**
+   * Manually flush all queued events
+   * Important for serverless/stateless environments where you need to ensure events are sent before the process exits
+   *
+   * @returns Response with batch results
+   *
+   * @example
+   * ```typescript
+   * // In serverless function
+   * await client.track({ name: 'api_call' });
+   * await client.flush(); // Ensure events are sent before function exits
+   * ```
+   */
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.queue.isEmpty()) {
+      return {
+        success: true,
+        processed: 0,
+        results: []
+      };
+    }
+    const events = this.queue.getAll();
+    this.queue.clear();
+    this.logger.info("Flushing events", { count: events.length });
+    return this.batch(events);
+  }
+  /**
+   * Send multiple custom events in a single batch request
+   * Max 100 events per batch
+   * Note: Usually you don't need to call this directly - use track() with batching enabled instead
+   *
+   * @param events - Array of custom events
+   * @returns Response with results for each event
+   *
+   * @example
+   * ```typescript
+   * await client.batch([
+   *   { type: 'custom', name: 'event1', properties: { foo: 'bar' } },
+   *   { type: 'custom', name: 'event2', properties: { baz: 'qux' } }
+   * ]);
+   * ```
+   */
+  async batch(events) {
+    if (!Array.isArray(events)) {
+      return {
+        success: false,
+        error: "Events must be an array"
+      };
+    }
+    if (events.length === 0) {
+      return {
+        success: false,
+        error: "Events array cannot be empty"
+      };
+    }
+    if (events.length > 100) {
+      return {
+        success: false,
+        error: "Batch size cannot exceed 100 events"
+      };
+    }
+    for (const event of events) {
+      if (!event.name || typeof event.name !== "string") {
+        return {
+          success: false,
+          error: "All events must have a valid name"
+        };
+      }
+    }
+    try {
+      const url = `${this.apiUrl}/batch?client_id=${encodeURIComponent(this.clientId)}`;
+      this.logger.info("\u{1F4E6} SENDING BATCH EVENTS:", {
+        count: events.length,
+        firstEventName: events[0]?.name,
+        firstEventProperties: JSON.stringify(events[0]?.properties, null, 2),
+        firstEventPropertiesCount: Object.keys(events[0]?.properties || {}).length
+      });
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(events)
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        this.logger.error("Batch request failed", {
+          status: response.status,
+          statusText: response.statusText,
+          body: errorText
+        });
+        return {
+          success: false,
+          error: `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      const data = await response.json();
+      this.logger.info("Batch response received", data);
+      if (data.status === "success") {
+        return {
+          success: true,
+          processed: data.processed,
+          results: data.results
+        };
+      }
+      return {
+        success: false,
+        error: data.message || "Unknown error from server"
+      };
+    } catch (error) {
+      this.logger.error("Batch request error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Network request failed"
+      };
+    }
+  }
+}
+
+export { Databuddy, Databuddy as db };

package/dist/react/index.d.mts

@@ -1,21 +1,12 @@
 export { b as Databuddy } from '../shared/@databuddy/sdk.C8T93n5r.mjs';
-import * as react from 'react';
 import { ReactNode } from 'react';
-import * as jotai from 'jotai';
 import { d as FlagsConfig, c as FlagState } from '../shared/@databuddy/sdk.YfiY9DoZ.mjs';
 export { b as FlagResult, e as FlagsContext } from '../shared/@databuddy/sdk.YfiY9DoZ.mjs';
 
 interface FlagsProviderProps extends FlagsConfig {
     children: ReactNode;
 }
-declare function FlagsProvider({ children, ...config }: FlagsProviderProps): react.FunctionComponentElement<{
-    children?: ReactNode;
-    store?: {
-        get: <Value>(atom: jotai.Atom<Value>) => Value;
-        set: <Value, Args extends unknown[], Result>(atom: jotai.WritableAtom<Value, Args, Result>, ...args: Args) => Result;
-        sub: (atom: jotai.Atom<unknown>, listener: () => void) => () => void;
-    };
-}>;
+declare function FlagsProvider({ children, ...config }: FlagsProviderProps): any;
 declare function useFlags(): {
     isEnabled: (key: string) => FlagState;
     fetchAllFlags: () => Promise<void> | undefined;

package/dist/react/index.d.ts

@@ -1,21 +1,12 @@
 export { b as Databuddy } from '../shared/@databuddy/sdk.C8T93n5r.js';
-import * as react from 'react';
 import { ReactNode } from 'react';
-import * as jotai from 'jotai';
 import { d as FlagsConfig, c as FlagState } from '../shared/@databuddy/sdk.YfiY9DoZ.js';
 export { b as FlagResult, e as FlagsContext } from '../shared/@databuddy/sdk.YfiY9DoZ.js';
 
 interface FlagsProviderProps extends FlagsConfig {
     children: ReactNode;
 }
-declare function FlagsProvider({ children, ...config }: FlagsProviderProps): react.FunctionComponentElement<{
-    children?: ReactNode;
-    store?: {
-        get: <Value>(atom: jotai.Atom<Value>) => Value;
-        set: <Value, Args extends unknown[], Result>(atom: jotai.WritableAtom<Value, Args, Result>, ...args: Args) => Result;
-        sub: (atom: jotai.Atom<unknown>, listener: () => void) => () => void;
-    };
-}>;
+declare function FlagsProvider({ children, ...config }: FlagsProviderProps): any;
 declare function useFlags(): {
     isEnabled: (key: string) => FlagState;
     fetchAllFlags: () => Promise<void> | undefined;

package/dist/react/index.mjs

@@ -1,9 +1,9 @@
 'use client';
 
-export { D as Databuddy } from '../shared/@databuddy/sdk.VZOaS2Dk.mjs';
+export { D as Databuddy } from '../shared/@databuddy/sdk.aVQee-4k.mjs';
 import { createStore, atom, Provider, useAtom } from 'jotai';
 import { useRef, useEffect, createElement } from 'react';
-import { B as BrowserFlagStorage, C as CoreFlagsManager, l as logger } from '../shared/@databuddy/sdk.DsZMb6-q.mjs';
+import { B as BrowserFlagStorage, C as CoreFlagsManager, l as logger } from '../shared/@databuddy/sdk.tFAHtL2M.mjs';
 
 const flagsStore = createStore();
 const managerAtom = atom(null);

package/dist/shared/@databuddy/{sdk.VZOaS2Dk.mjs → sdk.aVQee-4k.mjs}

@@ -1,4 +1,4 @@
-import { i as isScriptInjected, c as createScript } from './sdk.DsZMb6-q.mjs';
+import { i as isScriptInjected, c as createScript } from './sdk.tFAHtL2M.mjs';
 
 function detectClientId(providedClientId) {
   if (providedClientId) {

package/dist/shared/@databuddy/{sdk.DsZMb6-q.mjs → sdk.tFAHtL2M.mjs}

@@ -434,7 +434,7 @@ class CoreFlagsManager {
   }
 }
 
-const version = "2.1.76";
+const version = "2.2.0";
 
 const INJECTED_SCRIPT_ATTRIBUTE = "data-databuddy-injected";
 function isScriptInjected() {

package/dist/vue/index.d.mts

@@ -1,201 +1,8 @@
-import * as vue from 'vue';
 import { App, ComputedRef } from 'vue';
 import { d as FlagsConfig, c as FlagState, b as FlagResult } from '../shared/@databuddy/sdk.YfiY9DoZ.mjs';
 export { e as FlagsContext } from '../shared/@databuddy/sdk.YfiY9DoZ.mjs';
 
-declare const Databuddy: vue.DefineComponent<{
-    clientId?: {
-        type: StringConstructor;
-        required: false;
-    } | undefined;
-    clientSecret?: {
-        type: StringConstructor;
-        required: false;
-    } | undefined;
-    apiUrl?: {
-        type: StringConstructor;
-        required: false;
-    } | undefined;
-    scriptUrl?: {
-        type: StringConstructor;
-        required: false;
-    } | undefined;
-    sdk?: {
-        type: StringConstructor;
-        required: false;
-    } | undefined;
-    sdkVersion?: {
-        type: StringConstructor;
-        required: false;
-    } | undefined;
-    disabled?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    debug?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    waitForProfile?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackScreenViews?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackHashChanges?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackSessions?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackAttributes?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackOutgoingLinks?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackInteractions?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackEngagement?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackScrollDepth?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackExitIntent?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackBounceRate?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackPerformance?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackWebVitals?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    trackErrors?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    enableObservability?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    observabilityService?: {
-        type: StringConstructor;
-        required: false;
-    } | undefined;
-    observabilityEnvironment?: {
-        type: StringConstructor;
-        required: false;
-    } | undefined;
-    observabilityVersion?: {
-        type: StringConstructor;
-        required: false;
-    } | undefined;
-    enableLogging?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    enableTracing?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    enableErrorTracking?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    samplingRate?: {
-        type: NumberConstructor;
-        required: false;
-    } | undefined;
-    enableRetries?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    maxRetries?: {
-        type: NumberConstructor;
-        required: false;
-    } | undefined;
-    initialRetryDelay?: {
-        type: NumberConstructor;
-        required: false;
-    } | undefined;
-    enableBatching?: {
-        type: BooleanConstructor;
-        required: false;
-    } | undefined;
-    batchSize?: {
-        type: NumberConstructor;
-        required: false;
-    } | undefined;
-    batchTimeout?: {
-        type: NumberConstructor;
-        required: false;
-    } | undefined;
-    skipPatterns?: {
-        type: never;
-        required: false;
-    } | undefined;
-    maskPatterns?: {
-        type: never;
-        required: false;
-    } | undefined;
-}, () => null, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{} & {
-    sdk?: string | undefined;
-    clientId?: string | undefined;
-    clientSecret?: string | undefined;
-    apiUrl?: string | undefined;
-    scriptUrl?: string | undefined;
-    sdkVersion?: string | undefined;
-    disabled?: boolean | undefined;
-    debug?: boolean | undefined;
-    waitForProfile?: boolean | undefined;
-    trackScreenViews?: boolean | undefined;
-    trackHashChanges?: boolean | undefined;
-    trackSessions?: boolean | undefined;
-    trackAttributes?: boolean | undefined;
-    trackOutgoingLinks?: boolean | undefined;
-    trackInteractions?: boolean | undefined;
-    trackEngagement?: boolean | undefined;
-    trackScrollDepth?: boolean | undefined;
-    trackExitIntent?: boolean | undefined;
-    trackBounceRate?: boolean | undefined;
-    trackPerformance?: boolean | undefined;
-    trackWebVitals?: boolean | undefined;
-    trackErrors?: boolean | undefined;
-    enableObservability?: boolean | undefined;
-    observabilityService?: string | undefined;
-    observabilityEnvironment?: string | undefined;
-    observabilityVersion?: string | undefined;
-    enableLogging?: boolean | undefined;
-    enableTracing?: boolean | undefined;
-    enableErrorTracking?: boolean | undefined;
-    samplingRate?: number | undefined;
-    enableRetries?: boolean | undefined;
-    maxRetries?: number | undefined;
-    initialRetryDelay?: number | undefined;
-    enableBatching?: boolean | undefined;
-    batchSize?: number | undefined;
-    batchTimeout?: number | undefined;
-    skipPatterns?: any;
-    maskPatterns?: any;
-}>, {}>;
+declare const Databuddy: any;
 
 interface FlagsPluginOptions extends FlagsConfig {
 }