@databuddy/sdk 2.1.78 → 2.2.0

package/dist/core/index.mjs

@@ -1,6 +1,6 @@
-import { D as Databuddy$1 } from '../shared/@databuddy/sdk.CHuEu0ou.mjs';
-export { d as detectClientId } from '../shared/@databuddy/sdk.CHuEu0ou.mjs';
-export { B as BrowserFlagStorage, C as CoreFlagsManager, c as createScript, i as isScriptInjected } from '../shared/@databuddy/sdk.ItWNeH-Y.mjs';
+import { D as Databuddy$1 } from '../shared/@databuddy/sdk.aVQee-4k.mjs';
+export { d as detectClientId } from '../shared/@databuddy/sdk.aVQee-4k.mjs';
+export { B as BrowserFlagStorage, C as CoreFlagsManager, c as createScript, i as isScriptInjected } from '../shared/@databuddy/sdk.tFAHtL2M.mjs';
 
 function isTrackerAvailable() {
   return typeof window !== "undefined" && (!!window.databuddy || !!window.db);

package/dist/node/index.d.mts

@@ -0,0 +1,132 @@
+interface Logger {
+    info(msg: string, data?: Record<string, unknown>): void;
+    error(msg: string, data?: Record<string, unknown>): void;
+    warn(msg: string, data?: Record<string, unknown>): void;
+    debug(msg: string, data?: Record<string, unknown>): void;
+}
+
+interface DatabuddyConfig {
+    clientId: string;
+    apiUrl?: string;
+    debug?: boolean;
+    logger?: Logger;
+    /**
+     * Enable automatic batching of events
+     * Default: true
+     */
+    enableBatching?: boolean;
+    /**
+     * Number of events to batch before auto-flushing
+     * Default: 10, Max: 100
+     */
+    batchSize?: number;
+    /**
+     * Time in milliseconds before auto-flushing batched events
+     * Default: 2000ms (2 seconds)
+     */
+    batchTimeout?: number;
+    /**
+     * Maximum number of events to queue before auto-flushing
+     * Default: 1000
+     */
+    maxQueueSize?: number;
+}
+interface CustomEventInput {
+    name: string;
+    eventId?: string;
+    anonymousId?: string | null;
+    sessionId?: string | null;
+    timestamp?: number | null;
+    properties?: Record<string, unknown> | null;
+}
+interface EventResponse {
+    success: boolean;
+    eventId?: string;
+    error?: string;
+}
+interface BatchEventInput {
+    type: 'custom';
+    name: string;
+    eventId?: string;
+    anonymousId?: string | null;
+    sessionId?: string | null;
+    timestamp?: number | null;
+    properties?: Record<string, unknown> | null;
+}
+interface BatchEventResponse {
+    success: boolean;
+    processed?: number;
+    results?: Array<{
+        status: string;
+        type?: string;
+        eventId?: string;
+        message?: string;
+        error?: string;
+    }>;
+    error?: string;
+}
+
+declare class Databuddy {
+    private clientId;
+    private apiUrl;
+    private logger;
+    private enableBatching;
+    private batchSize;
+    private batchTimeout;
+    private queue;
+    private flushTimer;
+    constructor(config: DatabuddyConfig);
+    /**
+     * 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' }
+     * });
+     * ```
+     */
+    track(event: CustomEventInput): Promise<EventResponse>;
+    private send;
+    private scheduleFlush;
+    /**
+     * 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
+     * ```
+     */
+    flush(): Promise<BatchEventResponse>;
+    /**
+     * 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' } }
+     * ]);
+     * ```
+     */
+    batch(events: BatchEventInput[]): Promise<BatchEventResponse>;
+}
+
+export { Databuddy, Databuddy as db };
+export type { BatchEventInput, BatchEventResponse, CustomEventInput, DatabuddyConfig, EventResponse, Logger };

package/dist/node/index.d.ts

@@ -0,0 +1,132 @@
+interface Logger {
+    info(msg: string, data?: Record<string, unknown>): void;
+    error(msg: string, data?: Record<string, unknown>): void;
+    warn(msg: string, data?: Record<string, unknown>): void;
+    debug(msg: string, data?: Record<string, unknown>): void;
+}
+
+interface DatabuddyConfig {
+    clientId: string;
+    apiUrl?: string;
+    debug?: boolean;
+    logger?: Logger;
+    /**
+     * Enable automatic batching of events
+     * Default: true
+     */
+    enableBatching?: boolean;
+    /**
+     * Number of events to batch before auto-flushing
+     * Default: 10, Max: 100
+     */
+    batchSize?: number;
+    /**
+     * Time in milliseconds before auto-flushing batched events
+     * Default: 2000ms (2 seconds)
+     */
+    batchTimeout?: number;
+    /**
+     * Maximum number of events to queue before auto-flushing
+     * Default: 1000
+     */
+    maxQueueSize?: number;
+}
+interface CustomEventInput {
+    name: string;
+    eventId?: string;
+    anonymousId?: string | null;
+    sessionId?: string | null;
+    timestamp?: number | null;
+    properties?: Record<string, unknown> | null;
+}
+interface EventResponse {
+    success: boolean;
+    eventId?: string;
+    error?: string;
+}
+interface BatchEventInput {
+    type: 'custom';
+    name: string;
+    eventId?: string;
+    anonymousId?: string | null;
+    sessionId?: string | null;
+    timestamp?: number | null;
+    properties?: Record<string, unknown> | null;
+}
+interface BatchEventResponse {
+    success: boolean;
+    processed?: number;
+    results?: Array<{
+        status: string;
+        type?: string;
+        eventId?: string;
+        message?: string;
+        error?: string;
+    }>;
+    error?: string;
+}
+
+declare class Databuddy {
+    private clientId;
+    private apiUrl;
+    private logger;
+    private enableBatching;
+    private batchSize;
+    private batchTimeout;
+    private queue;
+    private flushTimer;
+    constructor(config: DatabuddyConfig);
+    /**
+     * 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' }
+     * });
+     * ```
+     */
+    track(event: CustomEventInput): Promise<EventResponse>;
+    private send;
+    private scheduleFlush;
+    /**
+     * 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
+     * ```
+     */
+    flush(): Promise<BatchEventResponse>;
+    /**
+     * 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' } }
+     * ]);
+     * ```
+     */
+    batch(events: BatchEventInput[]): Promise<BatchEventResponse>;
+}
+
+export { Databuddy, Databuddy as db };
+export type { BatchEventInput, BatchEventResponse, CustomEventInput, DatabuddyConfig, EventResponse, Logger };

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.mjs

@@ -1,9 +1,9 @@
 'use client';
 
-export { D as Databuddy } from '../shared/@databuddy/sdk.CHuEu0ou.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.ItWNeH-Y.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.CHuEu0ou.mjs → sdk.aVQee-4k.mjs}

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

package/dist/shared/@databuddy/{sdk.ItWNeH-Y.mjs → sdk.tFAHtL2M.mjs}

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

package/dist/vue/index.mjs

@@ -1,5 +1,5 @@
 import { defineComponent, ref, onMounted, onUnmounted, watch, reactive, watchEffect, computed } from 'vue';
-import { i as isScriptInjected, c as createScript, B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.ItWNeH-Y.mjs';
+import { i as isScriptInjected, c as createScript, B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.tFAHtL2M.mjs';
 
 const Databuddy = defineComponent({
   props: {},

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "@databuddy/sdk",
-  "version": "2.1.78",
+  "version": "2.2.0",
   "description": "Official Databuddy Analytics SDK",
   "main": "./dist/core/index.mjs",
   "types": "./dist/core/index.d.ts",
   "license": "MIT",
   "private": false,
   "scripts": {
-    "build": "unbuild"
+    "build": "unbuild",
+    "test": "bun test"
   },
   "dependencies": {
     "jotai": ">=2.0.0"
   },
+  "optionalDependencies": {
+    "pino": "^9.0.0"
+  },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "@vitejs/plugin-react": "^5.0.0",
@@ -42,6 +46,10 @@
     "./vue": {
       "types": "./dist/vue/index.d.ts",
       "import": "./dist/vue/index.mjs"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "import": "./dist/node/index.mjs"
     }
   },
   "files": [