@customerio/cdp-analytics-core 0.0.0-test-oidc

package/src/stats/index.ts

@@ -0,0 +1,88 @@
+type CompactMetricType = 'g' | 'c'
+
+export type CoreMetricType = 'gauge' | 'counter'
+
+export interface CoreMetric {
+  metric: string
+  value: number
+  type: CoreMetricType
+  tags: string[]
+  timestamp: number // unit milliseconds
+}
+
+export interface CompactMetric {
+  m: string // metric name
+  v: number // value
+  k: CompactMetricType
+  t: string[] // tags
+  e: number // timestamp in unit milliseconds
+}
+
+const compactMetricType = (type: CoreMetricType): CompactMetricType => {
+  const enums: Record<CoreMetricType, CompactMetricType> = {
+    gauge: 'g',
+    counter: 'c',
+  }
+  return enums[type]
+}
+
+export abstract class CoreStats {
+  metrics: CoreMetric[] = []
+  increment(metric: string, by = 1, tags?: string[]): void {
+    this.metrics.push({
+      metric,
+      value: by,
+      tags: tags ?? [],
+      type: 'counter',
+      timestamp: Date.now(),
+    })
+  }
+
+  gauge(metric: string, value: number, tags?: string[]): void {
+    this.metrics.push({
+      metric,
+      value,
+      tags: tags ?? [],
+      type: 'gauge',
+      timestamp: Date.now(),
+    })
+  }
+
+  flush(): void {
+    const formatted = this.metrics.map((m) => ({
+      ...m,
+      tags: m.tags.join(','),
+    }))
+    // ie doesn't like console.table
+    if (console.table) {
+      console.table(formatted)
+    } else {
+      console.log(formatted)
+    }
+    this.metrics = []
+  }
+
+  /**
+   * compact keys for smaller payload
+   */
+  serialize(): CompactMetric[] {
+    return this.metrics.map((m) => {
+      return {
+        m: m.metric,
+        v: m.value,
+        t: m.tags,
+        k: compactMetricType(m.type),
+        e: m.timestamp,
+      }
+    })
+  }
+}
+
+export class NullStats extends CoreStats {
+  override gauge(..._args: Parameters<CoreStats['gauge']>) {}
+  override increment(..._args: Parameters<CoreStats['increment']>) {}
+  override flush(..._args: Parameters<CoreStats['flush']>) {}
+  override serialize(..._args: Parameters<CoreStats['serialize']>) {
+    return []
+  }
+}

package/src/task/task-group.ts

@@ -0,0 +1,31 @@
+import { isThenable } from '../utils/is-thenable'
+
+export type TaskGroup = {
+  done: () => Promise<void>
+  run: <Operation extends (...args: any[]) => any>(
+    op: Operation
+  ) => ReturnType<Operation>
+}
+
+export const createTaskGroup = (): TaskGroup => {
+  let taskCompletionPromise: Promise<void>
+  let resolvePromise: () => void
+  let count = 0
+
+  return {
+    done: () => taskCompletionPromise,
+    run: (op) => {
+      const returnValue = op()
+
+      if (isThenable(returnValue)) {
+        if (++count === 1) {
+          taskCompletionPromise = new Promise((res) => (resolvePromise = res))
+        }
+
+        returnValue.finally(() => --count === 0 && resolvePromise())
+      }
+
+      return returnValue
+    },
+  }
+}

package/src/user/index.ts

@@ -0,0 +1,7 @@
+export type ID = string | null | undefined
+
+// TODO: this is a base user
+export interface User {
+  id(): ID
+  anonymousId(): ID
+}

package/src/utils/bind-all.ts

@@ -0,0 +1,19 @@
+export function bindAll<
+  ObjType extends { [key: string]: any },
+  KeyType extends keyof ObjType
+>(obj: ObjType): ObjType {
+  const proto = obj.constructor.prototype
+  for (const key of Object.getOwnPropertyNames(proto)) {
+    if (key !== 'constructor') {
+      const desc = Object.getOwnPropertyDescriptor(
+        obj.constructor.prototype,
+        key
+      )
+      if (!!desc && typeof desc.value === 'function') {
+        obj[key as KeyType] = obj[key].bind(obj)
+      }
+    }
+  }
+
+  return obj
+}

package/src/utils/environment.ts

@@ -0,0 +1,7 @@
+export function isBrowser(): boolean {
+  return typeof window !== 'undefined'
+}
+
+export function isServer(): boolean {
+  return !isBrowser()
+}

package/src/utils/get-global.ts

@@ -0,0 +1,16 @@
+// This an imperfect polyfill for globalThis
+export const getGlobal = () => {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis
+  }
+  if (typeof self !== 'undefined') {
+    return self
+  }
+  if (typeof window !== 'undefined') {
+    return window
+  }
+  if (typeof global !== 'undefined') {
+    return global
+  }
+  return null
+}

package/src/utils/group-by.ts

@@ -0,0 +1,30 @@
+type Grouper<T> = (obj: T) => string | number
+
+export function groupBy<T>(
+  collection: T[],
+  grouper: keyof T | Grouper<T>
+): Record<string, T[]> {
+  const results: Record<string, T[]> = {}
+
+  collection.forEach((item) => {
+    let key: string | number | undefined = undefined
+
+    if (typeof grouper === 'string') {
+      const suggestedKey = item[grouper]
+      key =
+        typeof suggestedKey !== 'string'
+          ? JSON.stringify(suggestedKey)
+          : suggestedKey
+    } else if (grouper instanceof Function) {
+      key = grouper(item)
+    }
+
+    if (key === undefined) {
+      return
+    }
+
+    results[key] = [...(results[key] ?? []), item]
+  })
+
+  return results
+}

package/src/utils/has-properties.ts

@@ -0,0 +1,7 @@
+export function hasProperties<T extends object, K extends string>(
+  obj: T,
+  ...keys: K[]
+): obj is T & { [J in K]: unknown } {
+  // eslint-disable-next-line no-prototype-builtins
+  return !!obj && keys.every((key) => obj.hasOwnProperty(key))
+}

package/src/utils/is-plain-object.ts

@@ -0,0 +1,26 @@
+// Code derived from https://github.com/jonschlinkert/is-plain-object/blob/master/is-plain-object.js
+
+function isObject(o: unknown): o is Object {
+  return Object.prototype.toString.call(o) === '[object Object]'
+}
+
+export function isPlainObject(o: unknown): o is Record<PropertyKey, unknown> {
+  if (isObject(o) === false) return false
+
+  // If has modified constructor
+  const ctor = (o as any).constructor
+  if (ctor === undefined) return true
+
+  // If has modified prototype
+  const prot = ctor.prototype
+  if (isObject(prot) === false) return false
+
+  // If constructor does not have an Object-specific method
+  // eslint-disable-next-line no-prototype-builtins
+  if ((prot as Object).hasOwnProperty('isPrototypeOf') === false) {
+    return false
+  }
+
+  // Most likely a plain Object
+  return true
+}

package/src/utils/is-thenable.ts

@@ -0,0 +1,9 @@
+/**
+ *  Check if  thenable
+ *  (instanceof Promise doesn't respect realms)
+ */
+export const isThenable = (value: unknown): boolean =>
+  typeof value === 'object' &&
+  value !== null &&
+  'then' in value &&
+  typeof (value as any).then === 'function'

package/src/utils/p-while.ts

@@ -0,0 +1,12 @@
+export const pWhile = async <T>(
+  condition: (value: T | undefined) => boolean,
+  action: () => T | PromiseLike<T>
+): Promise<void> => {
+  const loop = async (actionResult: T | undefined): Promise<void> => {
+    if (condition(actionResult)) {
+      return loop(await action())
+    }
+  }
+
+  return loop(undefined)
+}

package/src/utils/pick.ts

@@ -0,0 +1,8 @@
+export const pickBy = <T extends object, K extends keyof T>(
+  obj: T,
+  fn: (key: K, v: T[K]) => boolean
+) => {
+  return (Object.keys(obj) as K[])
+    .filter((k) => fn(k, obj[k]))
+    .reduce((acc, key) => ((acc[key] = obj[key]), acc), {} as Partial<T>)
+}

package/src/utils/ts-helpers.ts

@@ -0,0 +1,13 @@
+/**
+ * Remove Index Signature
+ */
+export type RemoveIndexSignature<T> = {
+  [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K]
+}
+
+/**
+ * Recursively make all object properties nullable
+ */
+export type DeepNullable<T> = {
+  [K in keyof T]: T[K] extends object ? DeepNullable<T[K]> | null : T[K] | null
+}

package/src/validation/assertions.ts

@@ -0,0 +1,54 @@
+import { CoreCustomerioEvent } from '../events'
+import { hasUser, isString, isPlainObject } from './helpers'
+
+export class ValidationError extends Error {
+  field: string
+
+  constructor(field: string, message: string) {
+    super(message)
+    this.field = field
+  }
+}
+
+export function assertMessageId(event: CoreCustomerioEvent): void {
+  if (!event.messageId) {
+    throw new ValidationError('messageId', 'messageId is missing')
+  }
+  if (!isString(event.messageId)) {
+    throw new ValidationError('messageId', 'messageId is not a string')
+  }
+}
+
+export function validateEvent(event?: CoreCustomerioEvent | null) {
+  if (!event || typeof event !== 'object') {
+    throw new ValidationError('event', 'Event is missing')
+  }
+
+  if (!isString(event.type)) {
+    throw new ValidationError('type', 'type is not a string')
+  }
+
+  assertMessageId(event)
+
+  if (event.type === 'track') {
+    if (!isString(event.event)) {
+      throw new ValidationError('event', 'Event is not a string')
+    }
+    if (!isPlainObject(event.properties)) {
+      throw new ValidationError('properties', 'properties is not an object')
+    }
+  }
+
+  if (['group', 'identify'].includes(event.type)) {
+    if (!isPlainObject(event.traits)) {
+      throw new ValidationError('traits', 'traits is not an object')
+    }
+  }
+
+  if (!hasUser(event)) {
+    throw new ValidationError(
+      'userId/anonymousId/previousId/groupId',
+      'Must have userId or anonymousId or previousId or groupId'
+    )
+  }
+}

package/src/validation/helpers.ts

@@ -0,0 +1,27 @@
+import { CoreCustomerioEvent } from '../events'
+
+export function isString(obj: unknown): obj is string {
+  return typeof obj === 'string'
+}
+
+export function isNumber(obj: unknown): obj is number {
+  return typeof obj === 'number'
+}
+
+export function isFunction(obj: unknown): obj is Function {
+  return typeof obj === 'function'
+}
+
+export function isPlainObject(
+  obj: unknown
+): obj is Record<string | symbol | number, any> {
+  return (
+    Object.prototype.toString.call(obj).slice(8, -1).toLowerCase() === 'object'
+  )
+}
+
+export function hasUser(event: CoreCustomerioEvent): boolean {
+  const id =
+    event.userId ?? event.anonymousId ?? event.groupId ?? event.previousId
+  return isString(id)
+}