cdp-lite-sdk 0.1.0

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "cdp-lite-sdk",
+  "version": "0.1.0",
+  "description": "Lightweight JS SDK to push events and manage attributes (demo)",
+  "main": "src/cdp-lite-sdk.js",
+  "type": "module",
+  "author": "Vi Nguyen",
+  "license": "MIT",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "rollup": "^4.54.0"
+  }
+}

package/src/cdp-lite-sdk.js

@@ -0,0 +1,393 @@
+// cdp-lite-sdk.test.js
+// VConnect Analytics SDK - Track events and users
+
+class CdpLiteSdk {
+  constructor(config) {
+    this.config = {
+      apiKey: config.apiKey,
+      source: config.source || 'Web',
+      serviceName: config.serviceName || 'DefaultService',
+      baseUrl: config.baseUrl || 'https://stg-ingestlog.vietcredit.com.vn',
+      isTest: config.isTest !== undefined ? config.isTest : false,
+      debug: config.debug || false,
+      batchSize: config.batchSize || 10,
+      batchInterval: config.batchInterval || 5000, // 5 seconds
+      autoTrackDevice: config.autoTrackDevice !== undefined ? config.autoTrackDevice : true,
+    };
+
+    this.eventQueue = [];
+    this.userId = null;
+    this.anonymousId = this._getOrCreateAnonymousId();
+    this.userTraits = {};
+    this.deviceInfo = this.config.autoTrackDevice ? this._getDeviceInfo() : {};
+
+    // Start batch processor
+    if (this.config.batchSize > 1) {
+      this._startBatchProcessor();
+    }
+
+    this._log('VConnect Analytics initialized', this.config);
+  }
+
+  // ============ Public Methods ============
+
+  /**
+   * Track an event
+   * @param {string} eventName - Name of the event
+   * @param {object} properties - Event properties
+   * @param {object} options - Additional options (device, campaign, context, etc.)
+   */
+  track(eventName, properties = {}, options = {}) {
+    const event = this._createEvent({
+      type: 'track',
+      event: eventName,
+      properties,
+      ...options
+    });
+
+    if (this.config.batchSize > 1) {
+      this._addToQueue(event);
+    } else {
+      return this._sendEvent(event);
+    }
+  }
+
+  /**
+   * Identify a user
+   * @param {string} userId - User ID
+   * @param {object} traits - User traits/attributes
+   */
+  identify(userId, traits = {}) {
+    this.userId = userId;
+    this.userTraits = { ...this.userTraits, ...traits };
+
+    const event = this._createEvent({
+      type: 'identify',
+      event: 'user_identified',
+      traits,
+    });
+
+    this._log('User identified', { userId, traits });
+
+    if (this.config.batchSize > 1) {
+      this._addToQueue(event);
+    } else {
+      return this._sendEvent(event);
+    }
+  }
+
+  /**
+   * Track a page view
+   * @param {string} pageName - Page name
+   * @param {object} properties - Page properties
+   */
+  page(pageName, properties = {}) {
+    return this.track('page_view', {
+      page_name: pageName,
+      ...properties
+    });
+  }
+
+  /**
+   * Track a screen view (for mobile apps)
+   * @param {string} screenName - Screen name
+   * @param {object} properties - Screen properties
+   */
+  screen(screenName, properties = {}) {
+    return this.track('screen_view', {
+      screen_name: screenName,
+      ...properties
+    });
+  }
+
+  /**
+   * Set user properties
+   * @param {object} traits - User traits
+   */
+  setUserAttributes(traits) {
+    this.userTraits = { ...this.userTraits, ...traits };
+    return this.identify(this.userId, traits);
+  }
+
+  /**
+   * Set device information
+   * @param {object} deviceInfo - Device information
+   */
+  setDeviceInfo(deviceInfo) {
+    this.deviceInfo = { ...this.deviceInfo, ...deviceInfo };
+  }
+
+  /**
+   * Manually flush the event queue
+   */
+  async flush() {
+    if (this.eventQueue.length === 0) {
+      return;
+    }
+
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+
+    return this._sendBatch(events);
+  }
+
+  /**
+   * Reset user data (logout)
+   */
+  reset() {
+    this.userId = null;
+    this.userTraits = {};
+    this.anonymousId = this._generateUUID();
+    this._saveAnonymousId(this.anonymousId);
+    this._log('User data reset');
+  }
+
+  // ============ Private Methods ============
+
+  _createEvent(data) {
+    const event = {
+      event_id: this._generateUUID(),
+      type: data.type || 'track',
+      event: data.event,
+      service_name: this.config.serviceName,
+      user_id: this.userId || '',
+      anonymous_id: this.anonymousId,
+      loan_code: data.loanCode || '',
+      properties: data.properties || {},
+      traits: data.traits || this.userTraits,
+      device: data.device || this.deviceInfo,
+      campaign: data.campaign || {},
+      context: data.context || {},
+      event_time: new Date().toISOString(),
+    };
+
+    return event;
+  }
+
+  async _sendEvent(event) {
+    const url = `${this.config.baseUrl}/api/v1/events/track`;
+    const headers = this._getHeaders();
+
+    try {
+      const response = await this._makeRequest(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(event),
+      });
+
+      this._log('Event tracked successfully', event);
+      return response;
+    } catch (error) {
+      this._logError('Failed to track event', error);
+      throw error;
+    }
+  }
+
+  async _sendBatch(events) {
+    if (events.length === 0) return;
+
+    const url = `${this.config.baseUrl}/api/v1/events/batch`;
+    const headers = this._getHeaders();
+
+    try {
+      const response = await this._makeRequest(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ events }),
+      });
+
+      this._log(`Batch of ${events.length} events tracked successfully`);
+      return response;
+    } catch (error) {
+      this._logError('Failed to track batch', error);
+      // Re-queue failed events
+      this.eventQueue.unshift(...events);
+      throw error;
+    }
+  }
+
+  _addToQueue(event) {
+    this.eventQueue.push(event);
+    this._log('Event added to queue', { queueSize: this.eventQueue.length });
+
+    if (this.eventQueue.length >= this.config.batchSize) {
+      this.flush();
+    }
+  }
+
+  _startBatchProcessor() {
+    this.batchInterval = setInterval(() => {
+      if (this.eventQueue.length > 0) {
+        this.flush();
+      }
+    }, this.config.batchInterval);
+
+    // Clean up on page unload (browser only)
+    if (typeof window !== 'undefined') {
+      window.addEventListener('beforeunload', () => {
+        this.flush();
+      });
+    }
+  }
+
+  _getHeaders() {
+    const timestamp = Math.floor(Date.now() / 1000);
+
+    return {
+      'X-Api-Key': this.config.apiKey,
+      'X-Source': this.config.source,
+      'X-Timestamp': timestamp.toString(),
+      'X-Signatures': '', // Implement signature logic if needed
+      'isTest': this.config.isTest.toString(),
+      'Content-Type': 'application/json',
+    };
+  }
+
+  async _makeRequest(url, options) {
+    // Support both browser fetch and Node.js
+    if (typeof fetch !== 'undefined') {
+      const response = await fetch(url, options);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return response.json();
+    } else {
+      // For Node.js environment
+      const https = require('https');
+      const urlObj = new URL(url);
+
+      return new Promise((resolve, reject) => {
+        const req = https.request({
+          hostname: urlObj.hostname,
+          path: urlObj.pathname + urlObj.search,
+          method: options.method,
+          headers: options.headers,
+        }, (res) => {
+          let data = '';
+          res.on('data', chunk => data += chunk);
+          res.on('end', () => {
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+              resolve(JSON.parse(data));
+            } else {
+              reject(new Error(`HTTP error! status: ${res.statusCode}`));
+            }
+          });
+        });
+
+        req.on('error', reject);
+        if (options.body) {
+          req.write(options.body);
+        }
+        req.end();
+      });
+    }
+  }
+
+  _getDeviceInfo() {
+    if (typeof window === 'undefined') {
+      // Node.js environment
+      return {
+        platform: process.platform,
+        brand: 'Server',
+        model: 'Node.js',
+        app_version: '',
+        os_version: process.version,
+      };
+    }
+
+    // Browser environment
+    const ua = navigator.userAgent;
+    const platform = this._detectPlatform(ua);
+
+    return {
+      platform,
+      brand: this._detectBrand(ua),
+      model: this._detectModel(ua),
+      app_version: '',
+      os_version: this._detectOSVersion(ua),
+    };
+  }
+
+  _detectPlatform(ua) {
+    if (/iPhone|iPad|iPod/.test(ua)) return 'ios';
+    if (/Android/.test(ua)) return 'android';
+    if (/Windows/.test(ua)) return 'windows';
+    if (/Mac/.test(ua)) return 'macos';
+    if (/Linux/.test(ua)) return 'linux';
+    return 'web';
+  }
+
+  _detectBrand(ua) {
+    if (/iPhone|iPad|iPod/.test(ua)) return 'Apple';
+    if (/Samsung/.test(ua)) return 'Samsung';
+    if (/Huawei/.test(ua)) return 'Huawei';
+    if (/Xiaomi/.test(ua)) return 'Xiaomi';
+    if (/Oppo/.test(ua)) return 'Oppo';
+    return 'Unknown';
+  }
+
+  _detectModel(ua) {
+    const match = ua.match(/\(([^)]+)\)/);
+    return match ? match[1].split(';')[0].trim() : 'Unknown';
+  }
+
+  _detectOSVersion(ua) {
+    const match = ua.match(/(?:Android|iPhone OS|CPU OS|Mac OS X|Windows NT) ([\d._]+)/);
+    return match ? match[1].replace(/_/g, '.') : 'Unknown';
+  }
+
+  _getOrCreateAnonymousId() {
+    if (typeof localStorage !== 'undefined') {
+      let id = localStorage.getItem('vconnect_anonymous_id');
+      if (!id) {
+        id = this._generateUUID();
+        this._saveAnonymousId(id);
+      }
+      return id;
+    }
+    return this._generateUUID();
+  }
+
+  _saveAnonymousId(id) {
+    if (typeof localStorage !== 'undefined') {
+      localStorage.setItem('vconnect_anonymous_id', id);
+    }
+  }
+
+  _generateUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+  }
+
+  _log(...args) {
+    if (this.config.debug) {
+      console.log('[VConnect Analytics]', ...args);
+    }
+  }
+
+  _logError(...args) {
+    if (this.config.debug) {
+      console.error('[VConnect Analytics]', ...args);
+    }
+  }
+
+  // Cleanup
+  destroy() {
+    if (this.batchInterval) {
+      clearInterval(this.batchInterval);
+    }
+    this.flush();
+  }
+}
+
+// Export for different module systems
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = CdpLiteSdk;
+}
+
+if (typeof window !== 'undefined') {
+  window.CdpLiteSdk = CdpLiteSdk;
+}