@ossy/analytics 3.11.1 → 3.12.0

package/src/page-view-location.aggregate.spec.js

@@ -0,0 +1,103 @@
+import { beforeEach, describe, expect, it, jest } from '@jest/globals'
+
+const resolveCountryCodeFromIp = jest.fn()
+
+jest.unstable_mockModule('./resolve-country-from-ip.js', () => ({
+  resolveCountryCodeFromIp,
+}))
+
+const {
+  PageViewLocationProjection,
+  pageViewLocationScopeId,
+} = await import('./page-view-location.aggregate.js')
+
+describe('PageViewLocationProjection', () => {
+  beforeEach(() => {
+    resolveCountryCodeFromIp.mockReset()
+  })
+
+  it('scopes by workspaceId:host', () => {
+    expect(pageViewLocationScopeId('ws-1', 'www.Ossy.se')).toBe('ws-1:ossy.se')
+    expect(PageViewLocationProjection.scopeFromEvent({
+      payload: { belongsTo: 'ws-1', content: { host: 'ossy.se' } },
+    })).toBe('ws-1:ossy.se')
+    expect(PageViewLocationProjection.scopeFromEvent({
+      payload: { belongsTo: 'ws-1', content: {} },
+    })).toBeNull()
+  })
+
+  it('folds MaxMind country into daily byDay buckets from event.created', async () => {
+    resolveCountryCodeFromIp.mockResolvedValue('SE')
+    const state = PageViewLocationProjection.initialState('ws-1:ossy.se')
+    const next = await PageViewLocationProjection.Apply({
+      resourceId: 'pv-1',
+      created: Date.parse('2026-09-05T12:00:00.000Z'),
+      ip: '203.0.113.10',
+      payload: {
+        belongsTo: 'ws-1',
+        content: { host: 'ossy.se' },
+      },
+    }, state)
+
+    expect(resolveCountryCodeFromIp).toHaveBeenCalledWith('203.0.113.10')
+    expect(next).toMatchObject({ workspaceId: 'ws-1', host: 'ossy.se' })
+    expect(next.byDay).toEqual({ '2026-09-05': { SE: 1 } })
+    expect(next).not.toHaveProperty('views')
+  })
+
+  it('increments the same day/country on further views', async () => {
+    resolveCountryCodeFromIp.mockResolvedValue('se')
+    const mid = await PageViewLocationProjection.Apply({
+      resourceId: 'pv-1',
+      created: Date.parse('2026-09-05T08:00:00.000Z'),
+      ip: '203.0.113.10',
+      payload: {
+        belongsTo: 'ws-1',
+        content: { host: 'ossy.se' },
+      },
+    }, PageViewLocationProjection.initialState('ws-1:ossy.se'))
+    const next = await PageViewLocationProjection.Apply({
+      resourceId: 'pv-2',
+      created: Date.parse('2026-09-05T18:00:00.000Z'),
+      ip: '203.0.113.11',
+      payload: {
+        belongsTo: 'ws-1',
+        content: { host: 'ossy.se' },
+      },
+    }, mid)
+
+    expect(next.byDay).toEqual({ '2026-09-05': { SE: 2 } })
+  })
+
+  it('leaves byDay unchanged when lookup misses', async () => {
+    resolveCountryCodeFromIp.mockResolvedValue(null)
+    const next = await PageViewLocationProjection.Apply({
+      resourceId: 'pv-2',
+      created: 42,
+      ip: '198.51.100.1',
+      payload: { belongsTo: 'ws-1', content: { host: 'ossy.se' } },
+    }, PageViewLocationProjection.initialState('ws-1:ossy.se'))
+
+    expect(next.byDay).toEqual({})
+  })
+
+  it('skips MaxMind when host is missing', async () => {
+    resolveCountryCodeFromIp.mockResolvedValue('SE')
+    const next = await PageViewLocationProjection.Apply({
+      resourceId: 'pv-3',
+      created: 42,
+      ip: '203.0.113.10',
+      payload: { belongsTo: 'ws-1', content: {} },
+    }, { workspaceId: 'ws-1', host: '', byDay: {} })
+
+    expect(resolveCountryCodeFromIp).not.toHaveBeenCalled()
+    expect(next.byDay).toEqual({})
+  })
+
+  it('invalidates the analytics get-page-view-stats action cache', () => {
+    expect(PageViewLocationProjection.cacheKeys('ws-1:ossy.se')).toEqual([
+      'projection:@ossy/analytics/data/page-view-location:ws-1:ossy.se',
+      'action:@ossy/analytics/actions/get-page-view-stats',
+    ])
+  })
+})

package/src/resolve-country-from-ip.js

@@ -0,0 +1,85 @@
+import maxmind from 'maxmind'
+
+/**
+ * Resolve ISO 3166-1 alpha-2 country from an IP via MaxMind GeoLite2-Country.
+ *
+ * Used by **PageViewLocationProjection** (not HTTP ingest). Database path:
+ * `GEOLITE2_COUNTRY_MMDB` (or `OSSY_GEOLITE2_COUNTRY_MMDB`). When unset /
+ * unreadable / lookup miss → null (callers omit `countryCode`).
+ * Never reads viewer-supplied country headers (#769).
+ *
+ * @param {string | null | undefined} ip
+ * @returns {Promise<string | null>}
+ */
+
+/** @type {import('maxmind').Reader<import('maxmind').CountryResponse> | null | undefined} */
+let reader
+/** @type {string | null | undefined} */
+let openedPath
+/** @type {Promise<import('maxmind').Reader<import('maxmind').CountryResponse> | null> | null} */
+let opening
+
+function resolveMmdbPath () {
+  const raw = process.env.GEOLITE2_COUNTRY_MMDB
+    ?? process.env.OSSY_GEOLITE2_COUNTRY_MMDB
+    ?? ''
+  const path = String(raw).trim()
+  return path || null
+}
+
+async function getReader () {
+  const path = resolveMmdbPath()
+  if (!path) {
+    reader = null
+    openedPath = null
+    return null
+  }
+  if (reader && openedPath === path) return reader
+  if (opening) return opening
+
+  opening = (async () => {
+    try {
+      reader = await maxmind.open(path)
+      openedPath = path
+      return reader
+    } catch {
+      reader = null
+      openedPath = path
+      return null
+    } finally {
+      opening = null
+    }
+  })()
+
+  return opening
+}
+
+/** Test helper — reset cached reader between specs. */
+export function resetGeoLite2CountryReaderForTests () {
+  reader = undefined
+  openedPath = undefined
+  opening = null
+}
+
+/**
+ * @param {string | null | undefined} ip
+ * @returns {Promise<string | null>}
+ */
+export async function resolveCountryCodeFromIp (ip) {
+  if (typeof ip !== 'string' || !ip.trim()) return null
+  const lookup = await getReader()
+  if (!lookup) return null
+
+  try {
+    const result = lookup.get(ip.trim())
+    const code = result?.country?.iso_code
+      ?? result?.registered_country?.iso_code
+    if (typeof code !== 'string') return null
+    const normalized = code.trim().toUpperCase()
+    if (!/^[A-Z]{2}$/.test(normalized)) return null
+    if (normalized === 'XX' || normalized === 'ZZ') return null
+    return normalized
+  } catch {
+    return null
+  }
+}

package/src/resolve-country-from-ip.spec.js

@@ -0,0 +1,52 @@
+import { describe, expect, it, jest, beforeEach, afterEach } from '@jest/globals'
+
+const open = jest.fn()
+
+jest.unstable_mockModule('maxmind', () => ({
+  default: { open },
+}))
+
+const { resolveCountryCodeFromIp, resetGeoLite2CountryReaderForTests } = await import('./resolve-country-from-ip.js')
+
+describe('resolveCountryCodeFromIp', () => {
+  const previousGeo = process.env.GEOLITE2_COUNTRY_MMDB
+  const previousOssy = process.env.OSSY_GEOLITE2_COUNTRY_MMDB
+
+  beforeEach(() => {
+    resetGeoLite2CountryReaderForTests()
+    open.mockReset()
+    delete process.env.GEOLITE2_COUNTRY_MMDB
+    delete process.env.OSSY_GEOLITE2_COUNTRY_MMDB
+  })
+
+  afterEach(() => {
+    resetGeoLite2CountryReaderForTests()
+    if (previousGeo == null) delete process.env.GEOLITE2_COUNTRY_MMDB
+    else process.env.GEOLITE2_COUNTRY_MMDB = previousGeo
+    if (previousOssy == null) delete process.env.OSSY_GEOLITE2_COUNTRY_MMDB
+    else process.env.OSSY_GEOLITE2_COUNTRY_MMDB = previousOssy
+  })
+
+  it('returns null when no mmdb path is configured', async () => {
+    expect(await resolveCountryCodeFromIp('8.8.8.8')).toBeNull()
+    expect(open).not.toHaveBeenCalled()
+  })
+
+  it('returns ISO country from MaxMind when the reader opens', async () => {
+    process.env.GEOLITE2_COUNTRY_MMDB = '/var/lib/GeoLite2-Country.mmdb'
+    open.mockResolvedValue({
+      get: (ip) => (ip === '8.8.8.8' ? { country: { iso_code: 'us' } } : null),
+    })
+
+    expect(await resolveCountryCodeFromIp('8.8.8.8')).toBe('US')
+    expect(await resolveCountryCodeFromIp('1.1.1.1')).toBeNull()
+    expect(await resolveCountryCodeFromIp('')).toBeNull()
+    expect(open).toHaveBeenCalledWith('/var/lib/GeoLite2-Country.mmdb')
+  })
+
+  it('returns null when MaxMind open fails', async () => {
+    process.env.GEOLITE2_COUNTRY_MMDB = '/missing.mmdb'
+    open.mockRejectedValue(new Error('ENOENT'))
+    expect(await resolveCountryCodeFromIp('8.8.8.8')).toBeNull()
+  })
+})

package/src/resolve-page-view-workspace.js

@@ -0,0 +1,110 @@
+const DOMAIN_SCHEMA_ID = '@ossy/domains/schema/managed-domain'
+
+/**
+ * @param {string} raw
+ * @returns {string}
+ */
+export function normalizeHost (raw) {
+  const host = String(raw || '').split(':')[0].trim().toLowerCase()
+  if (!host) return ''
+  return host.replace(/^www\./, '')
+}
+
+export function isLocalHost (host) {
+  return !host
+    || host === 'localhost'
+    || host === '127.0.0.1'
+    || host === '::1'
+    || host.endsWith('.localhost')
+}
+
+function hostFromHeaderUrl (value) {
+  if (!value) return ''
+  try {
+    return normalizeHost(new URL(String(value)).hostname)
+  } catch {
+    return ''
+  }
+}
+
+/**
+ * Host for public ingest. Prefer Origin (cross-origin POST) then Referer,
+ * then req.hostname. Client payload must not choose the Host.
+ *
+ * @param {{ hostname?: string, headers?: Record<string, string>, get?: Function } | null | undefined} req
+ * @returns {string}
+ */
+export function hostFromRequest (req) {
+  const headers = req?.headers || {}
+  const get = typeof req?.get === 'function'
+    ? (name) => req.get(name)
+    : (name) => headers[name] || headers[String(name).toLowerCase()]
+
+  return hostFromHeaderUrl(get('origin'))
+    || hostFromHeaderUrl(get('referer'))
+    || normalizeHost(req?.hostname || get('host'))
+}
+
+/**
+ * Workspace that registered this Host, or undefined. No cookie/config fallback.
+ *
+ * @param {{
+ *   host: string,
+ *   findDomain?: (host: string) => Promise<string | undefined>,
+ * }} opts
+ * @returns {Promise<string | undefined>}
+ */
+export async function resolvePageViewWorkspaceId ({ host, findDomain } = {}) {
+  const normalized = normalizeHost(host)
+  if (!normalized || !findDomain) return undefined
+  return findDomain(normalized)
+}
+
+function domainNameVariants (host) {
+  const normalized = normalizeHost(host)
+  if (!normalized) return []
+  return [normalized, `www.${normalized}`]
+}
+
+/**
+ * @param {{ findOne: Function }} collection
+ * @param {string} host
+ * @returns {Promise<string | undefined>}
+ */
+export async function workspaceIdForRegisteredHost (collection, host) {
+  const names = domainNameVariants(host)
+  if (!collection?.findOne || names.length === 0) return undefined
+  const doc = await collection.findOne({
+    type: DOMAIN_SCHEMA_ID,
+    'state.status': { $ne: 'removed' },
+    $or: [
+      { 'state.name': { $in: names } },
+      { 'state.content.Domain': { $in: names } },
+      { 'state.content.domain': { $in: names } },
+    ],
+  })
+  return doc?.state?.belongsTo || undefined
+}
+
+const CONTENT_KEYS = ['path', 'section', 'language', 'referrer', 'userAgent', 'visitorId']
+
+/**
+ * Persist only page-view fields. `host` always comes from the server.
+ * When the view happened is resource `created` (envelope), not content.
+ * Connection `ip` is stamped on the eventstore row at append (ADR 0016) — never from the client.
+ *
+ * @param {Record<string, unknown>} payload
+ * @param {{ userAgent?: string, path?: string, host?: string }} fallbacks
+ */
+export function pageViewContentFromPayload (payload, fallbacks = {}) {
+  const src = payload && typeof payload === 'object' ? payload : {}
+  const content = {}
+  for (const key of CONTENT_KEYS) {
+    const value = src[key]
+    if (value != null && value !== '') content[key] = value
+  }
+  if (content.userAgent == null && fallbacks.userAgent) content.userAgent = fallbacks.userAgent
+  content.path = content.path || fallbacks.path || '/'
+  if (fallbacks.host) content.host = fallbacks.host
+  return content
+}

package/src/resolve-page-view-workspace.spec.js

@@ -0,0 +1,101 @@
+import { describe, expect, it, jest } from '@jest/globals'
+import {
+  hostFromRequest,
+  isLocalHost,
+  normalizeHost,
+  pageViewContentFromPayload,
+  resolvePageViewWorkspaceId,
+  workspaceIdForRegisteredHost,
+} from './resolve-page-view-workspace.js'
+
+describe('normalizeHost', () => {
+  it('strips port and www', () => {
+    expect(normalizeHost('www.Ossy.se:443')).toBe('ossy.se')
+  })
+})
+
+describe('hostFromRequest', () => {
+  it('prefers Origin over hostname so cross-origin ingest uses the page Host', () => {
+    expect(hostFromRequest({
+      hostname: 'ossy.se',
+      headers: { origin: 'https://www.customer.com', host: 'ossy.se' },
+    })).toBe('customer.com')
+  })
+
+  it('falls back to hostname when Origin is missing', () => {
+    expect(hostFromRequest({ hostname: 'www.ossy.se:443' })).toBe('ossy.se')
+  })
+})
+
+describe('resolvePageViewWorkspaceId', () => {
+  it('looks up the Host and ignores cookies', async () => {
+    const findDomain = jest.fn(async () => 'ws-ossy')
+    const id = await resolvePageViewWorkspaceId({ host: 'ossy.se', findDomain })
+    expect(id).toBe('ws-ossy')
+    expect(findDomain).toHaveBeenCalledWith('ossy.se')
+  })
+
+  it('looks up localhost like any other Host', async () => {
+    const findDomain = jest.fn(async () => 'ws-local')
+    expect(await resolvePageViewWorkspaceId({
+      host: 'localhost',
+      findDomain,
+    })).toBe('ws-local')
+    expect(findDomain).toHaveBeenCalledWith('localhost')
+  })
+
+  it('returns undefined for unknown Hosts', async () => {
+    expect(await resolvePageViewWorkspaceId({
+      host: 'unknown.example',
+      findDomain: async () => undefined,
+    })).toBeUndefined()
+  })
+})
+
+describe('workspaceIdForRegisteredHost', () => {
+  it('matches apex or www name', async () => {
+    const findOne = jest.fn(async () => ({ state: { belongsTo: 'ws-1' } }))
+    await expect(workspaceIdForRegisteredHost({ findOne }, 'ossy.se')).resolves.toBe('ws-1')
+    expect(findOne).toHaveBeenCalledWith(expect.objectContaining({
+      $or: expect.arrayContaining([
+        { 'state.name': { $in: ['ossy.se', 'www.ossy.se'] } },
+        { 'state.content.Domain': { $in: ['ossy.se', 'www.ossy.se'] } },
+      ]),
+    }))
+  })
+
+  it('matches a Domains UI document by content.Domain', async () => {
+    const findOne = jest.fn(async () => ({ state: { belongsTo: 'ws-1' } }))
+    await expect(workspaceIdForRegisteredHost({ findOne }, 'localhost')).resolves.toBe('ws-1')
+    expect(findOne).toHaveBeenCalledWith(expect.objectContaining({
+      $or: expect.arrayContaining([
+        { 'state.content.Domain': { $in: ['localhost', 'www.localhost'] } },
+      ]),
+    }))
+  })
+})
+
+describe('pageViewContentFromPayload', () => {
+  it('keeps page-view fields, sets server host, drops workspaceId / ip / eventAt', () => {
+    expect(pageViewContentFromPayload({
+      path: '/pricing',
+      visitorId: 'v1',
+      workspaceId: 'ws-spoof',
+      ip: '1.2.3.4',
+      host: 'evil.example',
+      eventAt: 100,
+    }, { userAgent: 'Mozilla', path: '/', host: 'ossy.se' })).toEqual({
+      path: '/pricing',
+      visitorId: 'v1',
+      userAgent: 'Mozilla',
+      host: 'ossy.se',
+    })
+  })
+})
+
+describe('isLocalHost', () => {
+  it('treats loopback as local', () => {
+    expect(isLocalHost('localhost')).toBe(true)
+    expect(isLocalHost('ossy.se')).toBe(false)
+  })
+})

package/src/sv.translations.json

@@ -1,15 +1,18 @@
 {
   "analytics/home.documentTitle": "Analys",
   "analytics.home.title": "Analys",
-  "analytics.home.description": "Workspace-KPIer för medlemmar, resurser och trafik.",
+  "analytics.home.description": "Unika besökare och sidvisningar för en registrerad domän.",
   "analytics.home.overview": "Översikt",
   "analytics.home.traffic": "Trafik",
   "analytics.home.loading": "Laddar analys...",
   "analytics.home.error": "Kunde inte ladda analysdata.",
-  "analytics.home.members": "Medlemmar",
-  "analytics.home.resources": "Resurser",
-  "analytics.home.workspaceKpisError": "Kunde inte ladda workspace-KPIer.",
-  "analytics.home.totalPageViews": "Totala sidvisningar (30 dagar)",
+  "analytics.home.empty": "Registrera en domän för att se besökare och sidvisningar för den.",
+  "analytics.home.emptyEnableDomains": "Aktivera Domäner för workspace, registrera sedan en domän för att se besökare.",
+  "analytics.home.addDomain": "Lägg till en domän",
+  "analytics.home.enableDomains": "Aktivera domäner",
+  "analytics.home.hostLabel": "Domän",
+  "analytics.home.uniqueVisitors": "Besökare (30 dagar)",
+  "analytics.home.totalPageViews": "Sidvisningar (30 dagar)",
   "analytics.home.trackedPages": "Spårade sidor (30 dagar)",
   "analytics.home.daysWithTraffic": "Dagar med trafik",
   "analytics.home.topPaths": "Topp-sökvägar",
@@ -17,18 +20,26 @@
   "analytics.home.unknownPath": "(okänd sökväg)",
   "analytics.home.dailyPageViews": "Dagliga sidvisningar",
   "analytics.home.noDailyData": "Ingen daglig data ännu.",
-  "analytics.home.cover.title": "Se hur workspace används",
-  "analytics.home.cover.text": "Medlemmar, resurser och sidtrafik — KPIer för team som bygger på plattformen.",
+  "analytics.home.locations": "Besökarnas platser",
+  "analytics.home.noLocationData": "Ingen platsdata ännu. Land härleds från besökarens IP (GeoLite2) när det finns — råa IP-adresser visas inte.",
+  "analytics.home.cover.title": "Se vilka som besöker din sajt",
+  "analytics.home.cover.text": "Unika besökare och sidvisningar för varje domän du registrerar — även de som aldrig loggar in.",
   "analytics.home.cover.ctaPrimary": "Kom igång gratis",
-  "analytics.home.features.members.title": "Medlemmar",
-  "analytics.home.features.members.text": "Se hur många personer som finns i workspace.",
-  "analytics.home.features.resources.title": "Resurser",
-  "analytics.home.features.resources.text": "Följ hur mycket innehåll och data ni lagrar.",
+  "analytics.home.features.visitors.title": "Besökare",
+  "analytics.home.features.visitors.text": "Räkna alla på en registrerad domän — anonyma besökare och inloggade medlemmar.",
+  "analytics.home.features.paths.title": "Topp-sökvägar",
+  "analytics.home.features.paths.text": "Se vilka sidor folk öppnar mest under de senaste 30 dagarna.",
   "analytics.home.features.traffic.title": "Trafik",
-  "analytics.home.features.traffic.text": "Sidvisningar de senaste 30 dagarna, per sökväg och dag.",
+  "analytics.home.features.traffic.text": "Välj en domän i taget. Varje domän har egna besökar-, sidvisnings- och plats-siffror.",
   "analytics.sales.overview": "Översikt",
   "analytics.sales.features": "Funktioner",
   "analytics.sales.enable": "Aktivera analys",
-  "analytics.sales.enableDescription": "Aktivera analys för workspace för att se KPIer för medlemmar, resurser och trafik.",
-  "analytics.sales.enableError": "Kunde inte aktivera analys. Försök igen eller kontakta support."
+  "analytics.sales.enableDescription": "Aktivera analys för att se besökare och sidvisningar för domäner du registrerar.",
+  "analytics.sales.enableError": "Kunde inte aktivera analys. Försök igen eller kontakta support.",
+  "@ossy/analytics/actions/create-page-view.label": "Skapa sidvisning",
+  "@ossy/analytics/actions/create-page-view.description": "Registrera en sidvisning för en registrerad domän",
+  "@ossy/analytics/actions/get-page-view-stats.label": "Hämta sidvisningsstatistik",
+  "@ossy/analytics/actions/get-page-view-stats.description": "Hämta besökar- och sidvisningsstatistik för en registrerad domän",
+  "@ossy/analytics/actions/get-workspace-kpis.label": "Hämta workspace-KPIer",
+  "@ossy/analytics/actions/get-workspace-kpis.description": "Antal medlemmar och resurser för aktuellt workspace"
 }

package/src/usePageViewStats.js

@@ -1,8 +1,8 @@
 import { useEffect, useRef, useState } from 'react'
-import { GetPageViewStats } from '@ossy/resources'
+import { metadata as GetPageViewStats } from './get-page-view-stats.action.js'
 import { useSdk } from '@ossy/sdk-react'
 
-export function usePageViewStats({ workspaceId, from, to, limit = 10 }) {
+export function usePageViewStats({ workspaceId, host, from, to, limit = 10 }) {
   const sdk = useSdk()
   const invokeRef = useRef(sdk.invoke)
   invokeRef.current = sdk.invoke
@@ -10,23 +10,28 @@ export function usePageViewStats({ workspaceId, from, to, limit = 10 }) {
   const [status, setStatus] = useState('idle')
   const [data, setData] = useState({
     totalViews: 0,
+    uniqueVisitors: 0,
     dailyViews: [],
     topPaths: [],
+    byCountry: [],
   })
 
   useEffect(() => {
-    if (!workspaceId) return undefined
+    if (!workspaceId || !host) return undefined
 
     let cancelled = false
-    setStatus((current) => (current === 'success' ? current : 'loading'))
+    setStatus('loading')
 
-    invokeRef.current(GetPageViewStats, { from, to, limit })
+    // countryLimit stays at the task default (~250 ISO codes); do not reuse top-paths `limit`.
+    invokeRef.current(GetPageViewStats, { host, from, to, limit })
       .then((json) => {
         if (cancelled) return
         setData({
           totalViews: json?.totalViews || 0,
+          uniqueVisitors: json?.uniqueVisitors || 0,
           dailyViews: json?.dailyViews || [],
           topPaths: json?.topPaths || [],
+          byCountry: json?.byCountry || [],
         })
         setStatus('success')
       })
@@ -38,7 +43,7 @@ export function usePageViewStats({ workspaceId, from, to, limit = 10 }) {
     return () => {
       cancelled = true
     }
-  }, [workspaceId, from, to, limit])
+  }, [workspaceId, host, from, to, limit])
 
   return {
     status,

package/src/view-analytics.flow.js

@@ -8,18 +8,18 @@ export const metadata = {
 }
 
 /**
- * After enabling analytics, wait until workspace KPIs and page-view stats
- * settle so the product home overview is ready (not just mounted).
+ * After enabling analytics, wait until the product home settles.
+ * New workspaces have no domain, so the overview is empty — not traffic-ready.
  */
 export default {
   title: 'View analytics overview',
   description:
-    'Signed-in user enables analytics and sees the product overview settle to ready',
+    'Signed-in user enables analytics and sees an empty Host state or traffic for a registered domain',
   steps: [
     ...enableAnalyticsFlow.steps,
     {
       result: {
-        selector: '[data-analytics-overview-status="ready"]',
+        selector: '[data-analytics-overview-status="empty"], [data-analytics-overview-status="ready"]',
         timeout: 20000,
       },
     },

package/src/useWorkspaceKpis.js

@@ -1,45 +0,0 @@
-import { useEffect, useRef, useState } from 'react'
-import { useSdk } from '@ossy/sdk-react'
-import { metadata as GetWorkspaceKpis } from './get-workspace-kpis.action.js'
-
-export function useWorkspaceKpis({ workspaceId }) {
-  const sdk = useSdk()
-  const invokeRef = useRef(sdk.invoke)
-  invokeRef.current = sdk.invoke
-
-  const [status, setStatus] = useState('idle')
-  const [data, setData] = useState({
-    members: 0,
-    resources: 0,
-  })
-
-  useEffect(() => {
-    if (!workspaceId) return undefined
-
-    let cancelled = false
-    setStatus((current) => (current === 'success' ? current : 'loading'))
-
-    invokeRef.current(GetWorkspaceKpis, {})
-      .then((json) => {
-        if (cancelled) return
-        setData({
-          members: json?.members || 0,
-          resources: json?.resources || 0,
-        })
-        setStatus('success')
-      })
-      .catch(() => {
-        if (cancelled) return
-        setStatus('error')
-      })
-
-    return () => {
-      cancelled = true
-    }
-  }, [workspaceId])
-
-  return {
-    status,
-    ...data,
-  }
-}