@codeleap/analytics 5.0.11 → 5.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeleap/analytics",
-  "version": "5.0.11",
+  "version": "5.0.12",
   "main": "src/index.ts",
   "license": "UNLICENSED",
   "repository": {
@@ -9,13 +9,15 @@
     "directory": "packages/analytics"
   },
   "devDependencies": {
-    "@codeleap/config": "5.0.11",
+    "@codeleap/config": "5.0.12",
     "ts-node-dev": "1.1.8"
   },
   "scripts": {
     "build": "echo 'No build needed'"
   },
   "peerDependencies": {
+    "@codeleap/utils": "5.0.12",
+    "@codeleap/types": "5.0.12",
     "typescript": "5.5.2"
   }
 }

package/package.json.bak

@@ -1,6 +1,6 @@
 {
   "name": "@codeleap/analytics",
-  "version": "5.0.11",
+  "version": "5.0.12",
   "main": "src/index.ts",
   "license": "UNLICENSED",
   "repository": {
@@ -16,6 +16,8 @@
     "build": "echo 'No build needed'"
   },
   "peerDependencies": {
+    "@codeleap/utils": "workspace:*",
+    "@codeleap/types": "workspace:*",
     "typescript": "5.5.2"
   }
 }

package/src/Analytics/index.ts

@@ -0,0 +1,60 @@
+import { AnyFunction, AnyRecord } from '@codeleap/types'
+import { obfuscate } from '../obfuscate'
+import { AnalyticsFunctions, AnalyticsObject, AnalyticsOptions } from './types'
+
+export * from './types'
+
+export class Analytics<Events extends AnyRecord> {
+  private enabled: boolean
+
+  private prepareAnalyticsData() {
+    const data = this.options.prepareData()
+    return data
+  }
+
+  private obfuscateAnalyticsData(data: any) {
+    return obfuscate({
+      object: data,
+      keys: this.options.obfuscateKeys || [],
+      values: this.options.obfuscateValues || [],
+    })
+  }
+
+  constructor(
+    private options: AnalyticsOptions,
+    private functions: AnalyticsFunctions
+  ) {
+    this.enabled = options.enabled
+    
+    if (options.enabled) {
+      this.options.init()
+    }
+  }
+
+  event<T extends keyof Events>(name: T, data: Events[T] = {} as Events[T]) {
+    this.handle(name, data, 'event', this.functions.onEvent)
+  }
+
+  interaction<T extends keyof Events>(name: T, data: Events[T] = {} as Events[T]) {
+    this.handle(name, data, 'interaction', this.functions.onInteraction)
+  }
+
+  private handle(name: keyof Events, data: any, type: AnalyticsObject['type'], fn: AnyFunction) {
+    if (!this.enabled) return
+
+    try {
+      const obfuscated = this.obfuscateAnalyticsData({
+        ...data,
+        ...this.prepareAnalyticsData(),
+      })
+
+      fn({
+        name,
+        type,
+        data: obfuscated,
+      })
+    } catch (e) {
+      this.functions.onError(e)
+    }
+  }
+}

package/src/Analytics/types.ts

@@ -0,0 +1,21 @@
+import { Matcher } from '@codeleap/types'
+
+export type AnalyticsObject = {
+  name: string
+  type: 'interaction' | 'event'
+  data: any
+}
+
+export type AnalyticsFunctions = {
+  onError: (err: any) => void
+  onInteraction: (obj: AnalyticsObject) => void
+  onEvent: (obj: AnalyticsObject) => void
+}
+
+export type AnalyticsOptions = {
+  enabled: boolean
+  obfuscateKeys: Matcher<'key'>[]
+  obfuscateValues: Matcher<'value'>[]
+  init: () => void
+  prepareData: () => any
+}

package/src/index.ts

@@ -1 +1,2 @@
-export * from './Segment'
+export * from './Segment'
+export * from './Analytics'

package/src/obfuscate.ts

@@ -0,0 +1,76 @@
+import { cloneDeep } from '@codeleap/utils'
+import { Matcher } from '@codeleap/types'
+import { inspect } from 'util'
+import parse from 'url-parse'
+
+type ObfuscateArgs = {
+  object: any
+  keys: (Matcher<'key'>)[]
+  values: (Matcher<'value'>)[]
+}
+
+function removeKey(obj, key) {
+  if (obj?.hasOwnProperty(key)) {
+    obj[key] = '[secret]'
+  }
+  for (const subObj in obj) {
+    if (typeof obj[subObj] == 'object') {
+      removeKey(obj[subObj], key)
+    }
+  }
+}
+
+function removeValue(obj, value) {
+  for (const subObj in obj) {
+    const isString = typeof obj[subObj] == 'string'
+    if (isString) {
+      const isRegex = value instanceof RegExp
+      const match = isRegex ? value.test(obj[subObj]) : obj[subObj].includes(value)
+      if (match) {
+        if (obj[subObj].startsWith('http')) {
+          const url = parse(obj[subObj])
+          obj[subObj] = `${url.origin}${url.pathname}/[secret]`
+        } else {
+          obj[subObj] = '[secret]'
+        }
+      }
+    }
+    if (typeof obj[subObj] == 'object') {
+      removeValue(obj[subObj], value)
+    }
+  }
+}
+
+export function obfuscate(args: ObfuscateArgs) {
+  const { object, keys, values } = args
+
+  let isCircular = false
+  try {
+    JSON.stringify(args)
+  } catch (e) {
+    isCircular = true
+  }
+
+  if (typeof object === 'object' && !isCircular) {
+    let cleanData = {}
+    try {
+      cleanData = cloneDeep(object)
+      keys.forEach(fieldName => removeKey(cleanData, fieldName))
+      values.forEach(fieldName => removeValue(cleanData, fieldName))
+    } catch (err1) {
+      try {
+        cleanData = inspect(object, { depth: 1 })
+      } catch (err2) {
+        cleanData = { value: `Couldn't process data` }
+      }
+    }
+    const result = cleanData
+    return result
+  } else {
+    if (isCircular) {
+      return { ...args.object, WARNING: 'Circular reference detected' }
+    } else {
+      return args.object
+    }
+  }
+}