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

package/dist/types/utils/get-global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-global.d.ts","sourceRoot":"","sources":["../../../src/utils/get-global.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,SAAS,gCAcrB,CAAA"}

package/dist/types/utils/group-by.d.ts

@@ -0,0 +1,4 @@
+type Grouper<T> = (obj: T) => string | number;
+export declare function groupBy<T>(collection: T[], grouper: keyof T | Grouper<T>): Record<string, T[]>;
+export {};
+//# sourceMappingURL=group-by.d.ts.map

package/dist/types/utils/group-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by.d.ts","sourceRoot":"","sources":["../../../src/utils/group-by.ts"],"names":[],"mappings":"AAAA,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAAA;AAE7C,wBAAgB,OAAO,CAAC,CAAC,EACvB,UAAU,EAAE,CAAC,EAAE,EACf,OAAO,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAwBrB"}

package/dist/types/utils/has-properties.d.ts

@@ -0,0 +1,4 @@
+export declare function hasProperties<T extends object, K extends string>(obj: T, ...keys: K[]): obj is T & {
+    [J in K]: unknown;
+};
+//# sourceMappingURL=has-properties.d.ts.map

package/dist/types/utils/has-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-properties.d.ts","sourceRoot":"","sources":["../../../src/utils/has-properties.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAC9D,GAAG,EAAE,CAAC,EACN,GAAG,IAAI,EAAE,CAAC,EAAE,GACX,GAAG,IAAI,CAAC,GAAG;KAAG,CAAC,IAAI,CAAC,GAAG,OAAO;CAAE,CAGlC"}

package/dist/types/utils/is-plain-object.d.ts

@@ -0,0 +1,2 @@
+export declare function isPlainObject(o: unknown): o is Record<PropertyKey, unknown>;
+//# sourceMappingURL=is-plain-object.d.ts.map

package/dist/types/utils/is-plain-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object.d.ts","sourceRoot":"","sources":["../../../src/utils/is-plain-object.ts"],"names":[],"mappings":"AAMA,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAmB3E"}

package/dist/types/utils/is-thenable.d.ts

@@ -0,0 +1,6 @@
+/**
+ *  Check if  thenable
+ *  (instanceof Promise doesn't respect realms)
+ */
+export declare const isThenable: (value: unknown) => boolean;
+//# sourceMappingURL=is-thenable.d.ts.map

package/dist/types/utils/is-thenable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-thenable.d.ts","sourceRoot":"","sources":["../../../src/utils/is-thenable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,OAID,CAAA"}

package/dist/types/utils/p-while.d.ts

@@ -0,0 +1,2 @@
+export declare const pWhile: <T>(condition: (value: T | undefined) => boolean, action: () => T | PromiseLike<T>) => Promise<void>;
+//# sourceMappingURL=p-while.d.ts.map

package/dist/types/utils/p-while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"p-while.d.ts","sourceRoot":"","sources":["../../../src/utils/p-while.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM,2CACoB,OAAO,uCAE3C,QAAQ,IAAI,CAQd,CAAA"}

package/dist/types/utils/pick.d.ts

@@ -0,0 +1,2 @@
+export declare const pickBy: <T extends object, K extends keyof T>(obj: T, fn: (key: K, v: T[K]) => boolean) => Partial<T>;
+//# sourceMappingURL=pick.d.ts.map

package/dist/types/utils/pick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../src/utils/pick.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM,yEAEQ,OAAO,eAKjC,CAAA"}

package/dist/types/utils/ts-helpers.d.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;
+};
+//# sourceMappingURL=ts-helpers.d.ts.map

package/dist/types/utils/ts-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/ts-helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI;KACnC,CAAC,IAAI,MAAM,CAAC,IAAI,EAAE,SAAS,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC5D,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;KAC3B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;CAC9E,CAAA"}

package/dist/types/validation/assertions.d.ts

@@ -0,0 +1,8 @@
+import { CoreCustomerioEvent } from '../events';
+export declare class ValidationError extends Error {
+    field: string;
+    constructor(field: string, message: string);
+}
+export declare function assertMessageId(event: CoreCustomerioEvent): void;
+export declare function validateEvent(event?: CoreCustomerioEvent | null): void;
+//# sourceMappingURL=assertions.d.ts.map

package/dist/types/validation/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../../src/validation/assertions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAG/C,qBAAa,eAAgB,SAAQ,KAAK;IACxC,KAAK,EAAE,MAAM,CAAA;gBAED,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI3C;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAOhE;AAED,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE,mBAAmB,GAAG,IAAI,QAgC/D"}

package/dist/types/validation/helpers.d.ts

@@ -0,0 +1,7 @@
+import { CoreCustomerioEvent } from '../events';
+export declare function isString(obj: unknown): obj is string;
+export declare function isNumber(obj: unknown): obj is number;
+export declare function isFunction(obj: unknown): obj is Function;
+export declare function isPlainObject(obj: unknown): obj is Record<string | symbol | number, any>;
+export declare function hasUser(event: CoreCustomerioEvent): boolean;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/types/validation/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/validation/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAE/C,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAEpD;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAEpD;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,QAAQ,CAExD;AAED,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,GACX,GAAG,IAAI,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,CAAC,CAI9C;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAI3D"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@customerio/cdp-analytics-core",
+  "version": "0.0.0-test-oidc",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/customerio/cdp-analytics-js",
+    "directory": "packages/core"
+  },
+  "license": "MIT",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "files": [
+    "dist/",
+    "src/",
+    "!**/__tests__/**",
+    "!*.tsbuildinfo"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "test": "yarn jest",
+    "lint": "yarn concurrently 'yarn:eslint .' 'yarn:tsc --noEmit'",
+    "build": "yarn concurrently 'yarn:build:*'",
+    "build:esm": "yarn tsc -p tsconfig.build.json",
+    "build:cjs": "yarn tsc -p tsconfig.build.json --outDir ./dist/cjs --module commonjs",
+    "watch": "yarn build:esm --watch",
+    "watch:test": "yarn test --watch",
+    "tsc": "yarn run -T tsc",
+    "eslint": "yarn run -T eslint",
+    "concurrently": "yarn run -T concurrently",
+    "jest": "yarn run -T jest"
+  },
+  "packageManager": "yarn@3.2.1",
+  "dependencies": {
+    "@lukeed/uuid": "^2.0.0",
+    "dset": "^3.1.2",
+    "tslib": "^2.4.1"
+  },
+  "stableVersion": "0.3.8"
+}

package/src/analytics/dispatch.ts

@@ -0,0 +1,58 @@
+import { CoreContext } from '../context'
+import { Callback } from '../events/interfaces'
+import { CoreEventQueue } from '../queue/event-queue'
+import { invokeCallback } from '../callback'
+import { Emitter } from '../emitter'
+
+export type DispatchOptions<Ctx extends CoreContext = CoreContext> = {
+  timeout?: number
+  debug?: boolean
+  callback?: Callback<Ctx>
+}
+
+/* The amount of time in ms to wait before invoking the callback. */
+export const getDelay = (startTimeInEpochMS: number, timeoutInMS?: number) => {
+  const elapsedTime = Date.now() - startTimeInEpochMS
+  // increasing the timeout increases the delay by almost the same amount -- this is weird legacy behavior.
+  return Math.max((timeoutInMS ?? 300) - elapsedTime, 0)
+}
+/**
+ * Push an event into the dispatch queue and invoke any callbacks.
+ *
+ * @param event - Event to enqueue.
+ * @param queue - Queue to dispatch against.
+ * @param emitter - This is typically an instance of "Analytics" -- used for metrics / progress information.
+ * @param options
+ */
+export async function dispatch<
+  Ctx extends CoreContext,
+  EQ extends CoreEventQueue<Ctx>
+>(
+  ctx: Ctx,
+  queue: EQ,
+  emitter: Emitter,
+  options?: DispatchOptions<Ctx>
+): Promise<Ctx> {
+  emitter.emit('dispatch_start', ctx)
+
+  const startTime = Date.now()
+  let dispatched: Ctx
+  if (queue.isEmpty()) {
+    dispatched = await queue.dispatchSingle(ctx)
+  } else {
+    dispatched = await queue.dispatch(ctx)
+  }
+
+  if (options?.callback) {
+    dispatched = await invokeCallback(
+      dispatched,
+      options.callback,
+      getDelay(startTime, options.timeout)
+    )
+  }
+  if (options?.debug) {
+    dispatched.flush()
+  }
+
+  return dispatched
+}

package/src/analytics/index.ts

@@ -0,0 +1,11 @@
+export interface CoreAnalytics {
+  track(...args: unknown[]): unknown
+  page(...args: unknown[]): unknown
+  identify(...args: unknown[]): unknown
+  group(...args: unknown[]): unknown
+  alias(...args: unknown[]): unknown
+  screen(...args: unknown[]): unknown
+  register(...plugins: unknown[]): Promise<unknown>
+  deregister(...plugins: unknown[]): Promise<unknown>
+  readonly VERSION: string
+}

package/src/callback/index.ts

@@ -0,0 +1,51 @@
+import { CoreContext } from '../context'
+import type { Callback } from '../events'
+
+export function pTimeout<T>(promise: Promise<T>, timeout: number): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(Error('Promise timed out'))
+    }, timeout)
+
+    promise
+      .then((val) => {
+        clearTimeout(timeoutId)
+        return resolve(val)
+      })
+      .catch(reject)
+  })
+}
+
+export function sleep(timeoutInMs: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, timeoutInMs))
+}
+
+/**
+ * @param ctx
+ * @param callback - the function to invoke
+ * @param delay - aka "timeout". The amount of time in ms to wait before invoking the callback.
+ */
+export function invokeCallback<Ctx extends CoreContext>(
+  ctx: Ctx,
+  callback: Callback<Ctx>,
+  delay: number
+): Promise<Ctx> {
+  const cb = () => {
+    try {
+      return Promise.resolve(callback(ctx))
+    } catch (err) {
+      return Promise.reject(err)
+    }
+  }
+
+  return (
+    sleep(delay)
+      // pTimeout ensures that the callback can't cause the context to hang
+      .then(() => pTimeout(cb(), 1000))
+      .catch((err) => {
+        ctx?.log('warn', 'Callback Error', { error: err })
+        ctx?.stats.increment('callback_error')
+      })
+      .then(() => ctx)
+  )
+}

package/src/connection/index.ts

@@ -0,0 +1,13 @@
+import { isBrowser } from '../utils/environment'
+
+export function isOnline(): boolean {
+  if (isBrowser()) {
+    return window.navigator.onLine
+  }
+
+  return true
+}
+
+export function isOffline(): boolean {
+  return !isOnline()
+}

package/src/context/index.ts

@@ -0,0 +1,123 @@
+import { CoreCustomerioEvent } from '../events/interfaces'
+
+import { v4 as uuid } from '@lukeed/uuid'
+import { dset } from 'dset'
+import { CoreLogger, LogLevel, LogMessage } from '../logger'
+import { CoreStats, CoreMetric, NullStats } from '../stats'
+
+export interface SerializedContext {
+  id: string
+  event: CoreCustomerioEvent
+  logs: LogMessage[]
+  metrics?: CoreMetric[]
+}
+
+export interface ContextFailedDelivery {
+  reason: unknown
+}
+
+export interface CancelationOptions {
+  retry?: boolean
+  reason?: string
+  type?: string
+}
+
+export class ContextCancelation {
+  retry: boolean
+  type: string
+  reason?: string
+
+  constructor(options: CancelationOptions) {
+    this.retry = options.retry ?? true
+    this.type = options.type ?? 'plugin Error'
+    this.reason = options.reason ?? ''
+  }
+}
+
+export abstract class CoreContext<
+  Event extends CoreCustomerioEvent = CoreCustomerioEvent
+> {
+  event: Event
+  logger: CoreLogger
+  stats: CoreStats
+  attempts = 0
+
+  private _failedDelivery?: ContextFailedDelivery
+  private _id: string
+
+  constructor(
+    event: Event,
+    id = uuid(),
+    stats: CoreStats = new NullStats(),
+    logger = new CoreLogger()
+  ) {
+    this.event = event
+    this._id = id
+    this.logger = logger
+    this.stats = stats
+  }
+
+  static system(): void {
+    // This should be overridden by the subclass to return an instance of the subclass.
+  }
+
+  isSame(other: CoreContext): boolean {
+    return other.id === this.id
+  }
+
+  cancel(error?: Error | ContextCancelation): never {
+    if (error) {
+      throw error
+    }
+
+    throw new ContextCancelation({ reason: 'Context Cancel' })
+  }
+
+  log(level: LogLevel, message: string, extras?: object): void {
+    this.logger.log(level, message, extras)
+  }
+
+  get id(): string {
+    return this._id
+  }
+
+  updateEvent(path: string, val: unknown): Event {
+    // Don't allow integrations that are set to false to be overwritten with integration settings.
+    if (path.split('.')[0] === 'integrations') {
+      const integrationName = path.split('.')[1]
+
+      if (this.event.integrations?.[integrationName] === false) {
+        return this.event
+      }
+    }
+
+    dset(this.event, path, val)
+    return this.event
+  }
+
+  failedDelivery(): ContextFailedDelivery | undefined {
+    return this._failedDelivery
+  }
+
+  setFailedDelivery(options: ContextFailedDelivery) {
+    this._failedDelivery = options
+  }
+
+  logs(): LogMessage[] {
+    return this.logger.logs
+  }
+
+  flush(): void {
+    this.logger.flush()
+    this.stats.flush()
+  }
+
+  toJSON(): SerializedContext {
+    return {
+      id: this._id,
+      event: this.event,
+      logs: this.logger.logs,
+      metrics: this.stats.metrics,
+    }
+  }
+}

package/src/emitter/index.ts

@@ -0,0 +1,65 @@
+type EventName = string
+type EventFnArgs = any[]
+type EmitterContract = Record<EventName, EventFnArgs>
+
+/**
+ * Event Emitter that takes the expected contract as a generic
+ * @example
+ * ```ts
+ *  type Contract = {
+ *    delivery_success: [DeliverySuccessResponse, Metrics],
+ *    delivery_failure: [DeliveryError]
+ * }
+ *  new Emitter<Contract>()
+ *  .on('delivery_success', (res, metrics) => ...)
+ *  .on('delivery_failure', (err) => ...)
+ * ```
+ */
+export class Emitter<Contract extends EmitterContract = EmitterContract> {
+  private callbacks: Partial<Contract> = {}
+  on<EventName extends keyof Contract>(
+    event: EventName,
+    callback: (...args: Contract[EventName]) => void
+  ): this {
+    if (!this.callbacks[event]) {
+      this.callbacks[event] = [callback] as Contract[EventName]
+    } else {
+      this.callbacks[event]!.push(callback)
+    }
+    return this
+  }
+
+  once<EventName extends keyof Contract>(
+    event: EventName,
+    callback: (...args: Contract[EventName]) => void
+  ): this {
+    const on = (...args: Contract[EventName]): void => {
+      this.off(event, on)
+      callback.apply(this, args)
+    }
+
+    this.on(event, on)
+    return this
+  }
+
+  off<EventName extends keyof Contract>(
+    event: EventName,
+    callback: (...args: Contract[EventName]) => void
+  ): this {
+    const fns = this.callbacks[event] ?? []
+    const without = fns.filter((fn) => fn !== callback) as Contract[EventName]
+    this.callbacks[event] = without
+    return this
+  }
+
+  emit<EventName extends keyof Contract>(
+    event: EventName,
+    ...args: Contract[EventName]
+  ): this {
+    const callbacks = this.callbacks[event] ?? []
+    callbacks.forEach((callback) => {
+      callback.apply(this, args)
+    })
+    return this
+  }
+}

package/src/emitter/interface.ts

@@ -0,0 +1,31 @@
+import { CoreContext } from '../context'
+
+/**
+ * This is the base contract for all emitted errors. This interface may be extended.
+ */
+export interface CoreEmittedError<Ctx extends CoreContext> {
+  /**
+   * e.g. 'delivery_failure'
+   */
+  code: string
+  /**
+   * Why the error occurred. This can be an actual error object or a just a message.
+   */
+  reason?: unknown
+  ctx?: Ctx
+}
+
+export type CoreEmitterContract<
+  Ctx extends CoreContext,
+  Err extends CoreEmittedError<Ctx> = CoreEmittedError<Ctx>
+> = {
+  alias: [ctx: Ctx]
+  track: [ctx: Ctx]
+  identify: [ctx: Ctx]
+  page: [ctx: Ctx]
+  screen: [ctx: Ctx]
+  group: [ctx: Ctx]
+  register: [pluginNames: string[]]
+  deregister: [pluginNames: string[]]
+  error: [error: Err]
+}