@wool-so/node 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wool-so/node",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Server-side analytics SDK for Wool.",
   "type": "module",
   "license": "UNLICENSED",

package/src/index.d.ts

@@ -1,4 +1,4 @@
-export const VERSION: '0.3.0'
+export const VERSION: '0.3.1'
 export const DEFAULT_ENDPOINT: 'https://wool-api.gurjas1882.workers.dev/v1/events'
 
 export type WoolPropertyValue = string | number | boolean | null | undefined
@@ -13,9 +13,9 @@ export interface WoolFetchResponse {
 export type WoolFetch = (
   input: string,
   init: {
-    method: 'POST'
+    method: 'GET' | 'POST'
     headers: Record<string, string>
-    body: string
+    body?: string
   }
 ) => Promise<WoolFetchResponse>
 
@@ -23,6 +23,14 @@ export interface WoolBaseOptions {
   endpoint?: string
   apiUrl?: string
   apiHost?: string
+  apiBaseUrl?: string
+  api_base_url?: string
+  appUrl?: string
+  app_url?: string
+  dashboardUrl?: string
+  dashboard_url?: string
+  baseUrl?: string
+  base_url?: string
   fetch?: WoolFetch
   enabled?: boolean
   referrer?: string
@@ -36,16 +44,6 @@ export interface WoolBaseOptions {
 }
 
 export type WoolInitOptions = WoolBaseOptions &
-  (
-    | {
-        projectId: string
-        project_id?: string
-      }
-    | {
-        projectId?: string
-        project_id: string
-      }
-  ) &
   (
     | {
         apiKey: string
@@ -55,24 +53,13 @@ export type WoolInitOptions = WoolBaseOptions &
         apiKey?: string
         api_key: string
       }
-  ) &
-  (
-    | {
-        siteUrl: string
-        site_url?: string
-        url?: string
-      }
-    | {
-        siteUrl?: string
-        site_url: string
-        url?: string
-      }
-    | {
-        siteUrl?: string
-        site_url?: string
-        url: string
-      }
-  )
+  ) & {
+    projectId?: string
+    project_id?: string
+    siteUrl?: string
+    site_url?: string
+    url?: string
+  }
 
 export interface WoolIdentifyOptions {
   groupKey?: string
@@ -109,6 +96,8 @@ export interface WoolRequestContext {
 }
 
 export interface WoolTrackOptions extends WoolRequestContextOptions {
+  projectId?: string
+  project_id?: string
   request?: Request | WoolRequestLike
   req?: Request | WoolRequestLike
   source?: string
@@ -132,10 +121,91 @@ export interface WoolTrackOptions extends WoolRequestContextOptions {
 }
 
 export interface WoolPageviewOptions extends WoolRequestContextOptions {
+  projectId?: string
+  project_id?: string
   request?: Request | WoolRequestLike
   req?: Request | WoolRequestLike
 }
 
+export type WoolDatasetName =
+  | 'overview'
+  | 'performance'
+  | 'revenue'
+  | 'events'
+  | 'retention'
+  | 'goals'
+  | 'funnels'
+  | 'realtime'
+
+export interface WoolDatasetOptions {
+  projectId?: string
+  project_id?: string
+  range?: '24h' | '3d' | '7d' | '14d' | '30d' | '3mo' | '6mo' | '12mo' | string
+  currency?: string
+  event?: string
+  eventName?: string
+  selectedEvent?: string
+  propertyKey?: string
+  propertyValue?: string
+  entity?: 'user' | 'group' | string
+  granularity?: 'daily' | 'weekly' | 'monthly' | 'day' | 'week' | 'month' | string
+  startEvent?: string
+  returnEvent?: string
+}
+
+export interface WoolProject {
+  id: string
+  projectId: string
+  name: string
+  description?: string
+  siteUrl?: string
+  favicon?: string
+  createdAt?: string
+  updatedAt?: string
+}
+
+export type WoolJsonObject = Record<string, unknown>
+
+export interface WoolProjectsResponse {
+  projects: WoolProject[]
+}
+
+export interface WoolProjectResponse {
+  project: WoolProject
+}
+
+export type WoolDatasetResponse = WoolProjectResponse & WoolJsonObject
+
+export interface WoolDatasetsResponse {
+  project?: WoolProject
+  overview?: WoolJsonObject
+  performance?: WoolJsonObject
+  revenue?: WoolJsonObject
+  events?: WoolJsonObject
+  retention?: WoolJsonObject
+  goals?: WoolJsonObject
+  funnels?: WoolJsonObject
+  realtime?: WoolJsonObject
+}
+
+export interface WoolCard {
+  key: string
+  label: string
+  value: number | string
+  source: WoolDatasetName
+  unit?: string
+  currency?: string
+  [key: string]: unknown
+}
+
+export type WoolCardsByDataset = Record<WoolDatasetName, WoolCard[]>
+
+export interface WoolCardsResponse {
+  project?: WoolProject
+  cards: WoolCardsByDataset
+  datasets: WoolDatasetsResponse
+}
+
 export interface WoolResult {
   ok: boolean
   status: number
@@ -148,6 +218,19 @@ export interface WoolClient {
   reset(): void
   track(name: string, properties?: WoolProperties, options?: WoolTrackOptions): Promise<WoolResult>
   pageview(options?: WoolPageviewOptions): Promise<WoolResult>
+  projects(): Promise<WoolProjectsResponse>
+  project(options?: string | WoolDatasetOptions): Promise<WoolProjectResponse>
+  dataset(name: WoolDatasetName, options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+  datasets(options?: WoolDatasetOptions): Promise<WoolDatasetsResponse>
+  cards(options?: WoolDatasetOptions): Promise<WoolCardsResponse>
+  overview(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+  performance(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+  revenue(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+  events(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+  retention(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+  goals(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+  funnels(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+  realtime(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
   requestContext(input?: Request | WoolRequestLike | string, options?: WoolRequestContextOptions): WoolRequestContext
 }
 
@@ -163,6 +246,19 @@ export function identify(retentionId: string, options?: WoolIdentifyOptions): vo
 export function reset(): void
 export function track(name: string, properties?: WoolProperties, options?: WoolTrackOptions): Promise<WoolResult>
 export function pageview(options?: WoolPageviewOptions): Promise<WoolResult>
+export function projects(): Promise<WoolProjectsResponse>
+export function project(options?: string | WoolDatasetOptions): Promise<WoolProjectResponse>
+export function dataset(name: WoolDatasetName, options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+export function datasets(options?: WoolDatasetOptions): Promise<WoolDatasetsResponse>
+export function cards(options?: WoolDatasetOptions): Promise<WoolCardsResponse>
+export function overview(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+export function performance(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+export function revenue(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+export function events(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+export function retention(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+export function goals(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+export function funnels(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
+export function realtime(options?: WoolDatasetOptions): Promise<WoolDatasetResponse>
 export function requestContext(
   input?: Request | WoolRequestLike | string,
   options?: WoolRequestContextOptions
@@ -185,6 +281,19 @@ export function honoMiddleware(options: WoolInitOptions | WoolClient): HonoMiddl
 export const wool: WoolClient & {
   init: typeof init
   createClient: typeof createClient
+  cards: typeof cards
+  dataset: typeof dataset
+  datasets: typeof datasets
+  events: typeof events
+  funnels: typeof funnels
+  goals: typeof goals
+  overview: typeof overview
+  performance: typeof performance
+  project: typeof project
+  projects: typeof projects
+  realtime: typeof realtime
+  retention: typeof retention
+  revenue: typeof revenue
   requestContext: typeof requestContext
   expressMiddleware: typeof expressMiddleware
   fastifyPlugin: typeof fastifyPlugin

package/src/index.js

@@ -1,9 +1,23 @@
-export const VERSION = '0.3.0'
+export const VERSION = '0.3.1'
 export const DEFAULT_ENDPOINT = 'https://wool-api.gurjas1882.workers.dev/v1/events'
 
+const DATASET_NAMES = new Set(['overview', 'performance', 'revenue', 'events', 'retention', 'goals', 'funnels', 'realtime'])
+const DATASET_QUERY_KEYS = {
+  overview: ['range'],
+  performance: ['range'],
+  revenue: ['range', 'currency'],
+  events: ['range', 'event', 'propertyKey', 'propertyValue'],
+  retention: ['range', 'entity', 'granularity', 'startEvent', 'returnEvent'],
+  goals: ['range'],
+  funnels: ['range'],
+  realtime: []
+}
+
 const IDENTITY_KEY_PATTERN =
   /^(anonymousId|anonymous_id|retentionId|retention_id|subjectKey|subject_key|groupKey|group_key)$/i
 const TRACK_OPTION_KEYS = new Set([
+  'projectId',
+  'project_id',
   'source',
   'eventId',
   'id',
@@ -58,10 +72,140 @@ function resolveEndpoint(options) {
   return cleanText(options.endpoint, 2048) || endpointFromApiUrl(options.apiUrl || options.apiHost) || DEFAULT_ENDPOINT
 }
 
+function resolveApiBaseUrl(options) {
+  const value = cleanText(
+    options.apiBaseUrl ||
+      options.api_base_url ||
+      options.appUrl ||
+      options.app_url ||
+      options.dashboardUrl ||
+      options.dashboard_url ||
+      options.baseUrl ||
+      options.base_url,
+    2048
+  )
+
+  return value.replace(/\/+$/, '')
+}
+
 function isPlainObject(value) {
   return Boolean(value && typeof value === 'object' && !Array.isArray(value))
 }
 
+function toNumber(value) {
+  const number = Number(value)
+  return Number.isFinite(number) ? number : 0
+}
+
+function valueAt(source, path) {
+  return path.reduce((current, key) => (current && current[key] !== undefined ? current[key] : undefined), source)
+}
+
+function card(key, label, value, source, options = {}) {
+  return {
+    key,
+    label,
+    value,
+    source,
+    ...options
+  }
+}
+
+function topConversion(goals = []) {
+  return Math.max(...goals.map((goal) => toNumber(goal?.stats?.conversionRate)), 0)
+}
+
+function bestFunnelConversion(funnels = []) {
+  return Math.max(...funnels.map((funnel) => toNumber(funnel?.conversionRate)), 0)
+}
+
+function lowestFunnelDropoff(funnels = []) {
+  return funnels.length ? Math.min(...funnels.map((funnel) => toNumber(funnel?.dropoffRate))) : 0
+}
+
+function buildCards(data) {
+  const overview = data.overview || {}
+  const realtime = data.realtime || {}
+  const revenue = data.revenue || {}
+  const retention = data.retention || {}
+  const goals = data.goals || {}
+  const funnels = data.funnels || {}
+  const events = data.events || {}
+  const performance = data.performance || {}
+
+  return {
+    overview: [
+      card('visitors', 'Visitors', toNumber(overview.visitors), 'overview'),
+      card('visits', 'Visits', toNumber(overview.visits), 'overview'),
+      card('pageviews', 'Pageviews', toNumber(overview.pageviews), 'overview'),
+      card('bounceRate', 'Bounce rate', toNumber(overview.bounceRate), 'overview', { unit: 'percent' }),
+      card('visitDuration', 'Visit duration', toNumber(overview.visitDuration), 'overview', { unit: 'seconds' })
+    ],
+    realtime: [
+      card('activeVisitors', 'Active visitors', toNumber(realtime.activeVisitors), 'realtime'),
+      card('visitors', 'Visitors', toNumber(realtime.visitors), 'realtime'),
+      card('pageviews', 'Pageviews', toNumber(realtime.pageviews), 'realtime'),
+      card('events', 'Events', toNumber(realtime.events), 'realtime')
+    ],
+    revenue: [
+      card('revenue', 'Revenue', toNumber(valueAt(revenue, ['totals', 'revenue'])), 'revenue', {
+        currency: revenue.selectedCurrency || ''
+      }),
+      card('purchases', 'Purchases', toNumber(valueAt(revenue, ['totals', 'purchases'])), 'revenue'),
+      card('purchasers', 'Purchasers', toNumber(valueAt(revenue, ['totals', 'purchasers'])), 'revenue'),
+      card('averageOrderValue', 'AOV', toNumber(valueAt(revenue, ['totals', 'averageOrderValue'])), 'revenue', {
+        currency: revenue.selectedCurrency || ''
+      }),
+      card('conversionRate', 'Conversion', toNumber(valueAt(revenue, ['totals', 'conversionRate'])), 'revenue', {
+        unit: 'percent'
+      })
+    ],
+    retention: [
+      card('cohorts', 'Cohorts', toNumber(valueAt(retention, ['totals', 'cohorts'])), 'retention'),
+      card('subjects', 'Subjects', toNumber(valueAt(retention, ['totals', 'subjects'])), 'retention'),
+      card('retentionRate', 'Retention', toNumber(valueAt(retention, ['totals', 'retentionRate'])), 'retention', {
+        unit: 'percent',
+        retained: toNumber(valueAt(retention, ['totals', 'retained']))
+      }),
+      card('churnRate', 'Churn', toNumber(valueAt(retention, ['totals', 'churnRate'])), 'retention', {
+        unit: 'percent',
+        churned: toNumber(valueAt(retention, ['totals', 'churned']))
+      })
+    ],
+    goals: [
+      card('goals', 'Goals', Array.isArray(goals.goals) ? goals.goals.length : 0, 'goals'),
+      card('visitors', 'Visitors', toNumber(valueAt(goals, ['totals', 'visitors'])), 'goals'),
+      card('completions', 'Completions', toNumber(valueAt(goals, ['totals', 'completions'])), 'goals'),
+      card('topConversion', 'Top conversion', topConversion(goals.goals), 'goals', { unit: 'percent' })
+    ],
+    funnels: [
+      card('funnels', 'Funnels', Array.isArray(funnels.funnels) ? funnels.funnels.length : 0, 'funnels'),
+      card('availableGoals', 'Available goals', Array.isArray(funnels.goals) ? funnels.goals.length : 0, 'funnels'),
+      card('bestConversion', 'Best conversion', bestFunnelConversion(funnels.funnels), 'funnels', { unit: 'percent' }),
+      card('lowestDropoff', 'Lowest dropoff', lowestFunnelDropoff(funnels.funnels), 'funnels', { unit: 'percent' })
+    ],
+    events: [
+      card('events', 'Events', toNumber(valueAt(events, ['totals', 'events'])), 'events'),
+      card('visitors', 'Visitors', toNumber(valueAt(events, ['totals', 'visitors'])), 'events'),
+      card('visits', 'Visits', toNumber(valueAt(events, ['totals', 'visits'])), 'events'),
+      card('totalValue', 'Total value', toNumber(valueAt(events, ['totals', 'totalValue'])), 'events'),
+      card('averageDuration', 'Average duration', toNumber(valueAt(events, ['totals', 'averageDuration'])), 'events', {
+        unit: 'seconds'
+      })
+    ],
+    performance: (Array.isArray(performance.metrics) ? performance.metrics : []).map((metric) =>
+      card(metric.key || metric.name || 'metric', metric.label || metric.key || 'Metric', toNumber(metric.p75), 'performance', {
+        unit: metric.unit || 'ms',
+        p50: toNumber(metric.p50),
+        p75: toNumber(metric.p75),
+        p95: toNumber(metric.p95),
+        samples: toNumber(metric.samples),
+        status: metric.status || ''
+      })
+    )
+  }
+}
+
 function cleanProperties(properties) {
   if (!isPlainObject(properties)) return {}
 
@@ -207,13 +351,13 @@ function createState(options) {
   const apiKey = cleanText(options.apiKey || options.api_key, 4096)
   const siteUrl = cleanText(options.siteUrl || options.site_url || options.url, 2048)
 
-  if (!projectId) throw new WoolError('projectId is required.')
   if (!apiKey) throw new WoolError('apiKey is required.')
 
   return {
     projectId,
     apiKey,
     endpoint: resolveEndpoint(options),
+    apiBaseUrl: resolveApiBaseUrl(options),
     defaultUrl: siteUrl,
     defaultReferrer: cleanText(options.referrer || options.referer, 2048),
     enabled: options.enabled !== false,
@@ -229,9 +373,69 @@ function bodyFromResponse(response) {
   return response?.text ? response.text().catch(() => '') : Promise.resolve('')
 }
 
+function parseJson(text) {
+  if (!text) return {}
+
+  try {
+    return JSON.parse(text)
+  } catch {
+    return null
+  }
+}
+
+function normalizeRetentionGranularity(value) {
+  const text = String(value || '').trim().toLowerCase()
+  if (text === 'day' || text === 'daily') return 'daily'
+  if (text === 'week' || text === 'weekly') return 'weekly'
+  if (text === 'month' || text === 'monthly') return 'monthly'
+  return value
+}
+
 export function createClient(options = {}) {
   const state = createState(options)
 
+  function projectIdFrom(options = {}) {
+    const projectId = cleanText(options.projectId || options.project_id || state.projectId, 96)
+    if (!projectId) throw new WoolError('projectId is required.')
+    return projectId
+  }
+
+  function dataApiUrl(path, query = {}) {
+    if (!state.apiBaseUrl) {
+      throw new WoolError('apiBaseUrl, appUrl, dashboardUrl, or baseUrl is required for analytics reads.')
+    }
+
+    const url = new URL(path, `${state.apiBaseUrl}/`)
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== undefined && value !== null && String(value).trim()) {
+        url.searchParams.set(key, String(value))
+      }
+    }
+
+    return url.toString()
+  }
+
+  async function requestJson(path, query = {}) {
+    const response = await state.fetch(dataApiUrl(path, query), {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${state.apiKey}`,
+        'X-API-Key': state.apiKey,
+        'X-Wool-SDK': `@wool-so/node/${VERSION}`
+      }
+    })
+    const body = await bodyFromResponse(response)
+    const data = parseJson(body)
+
+    if (!response?.ok) {
+      throw new WoolError(data?.error || body || 'Unable to fetch Wool analytics data.', response?.status || 0, response || null)
+    }
+
+    if (data === null) throw new WoolError('Wool analytics response must be valid JSON.', response?.status || 0, response || null)
+    return data
+  }
+
   async function send(payload) {
     if (!state.enabled) {
       return { ok: true, status: 0, skipped: true }
@@ -242,6 +446,7 @@ export function createClient(options = {}) {
       headers: {
         Authorization: `Bearer ${state.apiKey}`,
         'Content-Type': 'application/json',
+        'X-API-Key': state.apiKey,
         'X-Wool-SDK': `@wool-so/node/${VERSION}`
       },
       body: JSON.stringify(payload)
@@ -257,12 +462,14 @@ export function createClient(options = {}) {
 
   function basePayload(type, options = {}) {
     const context = requestContext(options.request || options.req, options)
+    const projectId = cleanText(options.projectId || options.project_id || state.projectId, 96)
     const url = cleanText(context.url || state.defaultUrl, 2048)
 
+    if (!projectId) throw new WoolError('projectId is required.')
     if (!url) throw new WoolError('url or siteUrl is required.')
 
     const payload = {
-      projectId: state.projectId,
+      projectId,
       type,
       url,
       referrer: cleanText(context.referrer || state.defaultReferrer, 2048),
@@ -304,6 +511,97 @@ export function createClient(options = {}) {
     return send(basePayload('pageview', options))
   }
 
+  async function projects() {
+    return requestJson('/api/projects')
+  }
+
+  async function project(options = {}) {
+    const projectId = typeof options === 'string' ? cleanText(options, 96) : projectIdFrom(options)
+    if (!projectId) throw new WoolError('projectId is required.')
+    return requestJson(`/api/projects/${encodeURIComponent(projectId)}`)
+  }
+
+  function datasetQuery(name, options = {}) {
+    const normalized = String(name || '').toLowerCase()
+    const keys = DATASET_QUERY_KEYS[normalized] || []
+    const query = {}
+
+    for (const key of keys) {
+      if (key === 'event') {
+        query.event = options.event || options.eventName || options.selectedEvent
+      } else if (key === 'granularity') {
+        query.granularity = normalizeRetentionGranularity(options.granularity)
+      } else {
+        query[key] = options[key]
+      }
+    }
+
+    return query
+  }
+
+  async function dataset(name, options = {}) {
+    const normalized = String(name || '').toLowerCase()
+    if (!DATASET_NAMES.has(normalized)) throw new WoolError('Unsupported Wool dataset.')
+
+    const projectId = projectIdFrom(options)
+    return requestJson(
+      `/api/projects/${encodeURIComponent(projectId)}/web/${encodeURIComponent(normalized)}`,
+      datasetQuery(normalized, options)
+    )
+  }
+
+  const overview = (options = {}) => dataset('overview', options)
+  const performance = (options = {}) => dataset('performance', options)
+  const revenue = (options = {}) => dataset('revenue', options)
+  const events = (options = {}) => dataset('events', options)
+  const retention = (options = {}) => dataset('retention', options)
+  const goals = (options = {}) => dataset('goals', options)
+  const funnels = (options = {}) => dataset('funnels', options)
+  const realtime = (options = {}) => dataset('realtime', options)
+
+  async function datasets(options = {}) {
+    const [
+      overviewResult,
+      performanceResult,
+      revenueResult,
+      eventsResult,
+      retentionResult,
+      goalsResult,
+      funnelsResult,
+      realtimeResult
+    ] = await Promise.all([
+      overview(options),
+      performance(options),
+      revenue(options),
+      events(options),
+      retention(options),
+      goals(options),
+      funnels(options),
+      realtime(options)
+    ])
+
+    return {
+      project: overviewResult.project,
+      overview: overviewResult.overview,
+      performance: performanceResult.performance,
+      revenue: revenueResult.revenue,
+      events: eventsResult.events,
+      retention: retentionResult.retention,
+      goals: goalsResult.goals,
+      funnels: funnelsResult.funnels,
+      realtime: realtimeResult.realtime
+    }
+  }
+
+  async function cards(options = {}) {
+    const data = await datasets(options)
+    return {
+      project: data.project,
+      cards: buildCards(data),
+      datasets: data
+    }
+  }
+
   function identify(retentionId, options = {}) {
     state.identity = {
       retentionId: cleanText(retentionId),
@@ -319,8 +617,21 @@ export function createClient(options = {}) {
   }
 
   return {
+    cards,
+    dataset,
+    datasets,
+    events,
+    funnels,
+    goals,
     identify,
+    overview,
     pageview,
+    performance,
+    project,
+    projects,
+    realtime,
+    retention,
+    revenue,
     requestContext,
     reset,
     track
@@ -387,12 +698,77 @@ export function pageview(options) {
   return requireDefaultClient().pageview(options)
 }
 
+export function projects() {
+  return requireDefaultClient().projects()
+}
+
+export function project(options) {
+  return requireDefaultClient().project(options)
+}
+
+export function dataset(name, options) {
+  return requireDefaultClient().dataset(name, options)
+}
+
+export function datasets(options) {
+  return requireDefaultClient().datasets(options)
+}
+
+export function cards(options) {
+  return requireDefaultClient().cards(options)
+}
+
+export function overview(options) {
+  return requireDefaultClient().overview(options)
+}
+
+export function performance(options) {
+  return requireDefaultClient().performance(options)
+}
+
+export function revenue(options) {
+  return requireDefaultClient().revenue(options)
+}
+
+export function events(options) {
+  return requireDefaultClient().events(options)
+}
+
+export function retention(options) {
+  return requireDefaultClient().retention(options)
+}
+
+export function goals(options) {
+  return requireDefaultClient().goals(options)
+}
+
+export function funnels(options) {
+  return requireDefaultClient().funnels(options)
+}
+
+export function realtime(options) {
+  return requireDefaultClient().realtime(options)
+}
+
 export const wool = {
   init,
+  cards,
+  dataset,
+  datasets,
+  events,
+  funnels,
+  goals,
   identify,
   reset,
+  overview,
   track,
   pageview,
+  performance,
+  project,
+  projects,
+  realtime,
+  retention,
+  revenue,
   createClient,
   requestContext,
   expressMiddleware,