@ossy/analytics 3.11.1 → 3.12.0

package/src/create-page-view.task.spec.js

@@ -0,0 +1,170 @@
+import { beforeEach, describe, expect, it, jest } from '@jest/globals'
+
+const findOne = jest.fn()
+const commitResource = jest.fn()
+const ofMock = jest.fn()
+
+jest.unstable_mockModule('nanoid', () => ({ nanoid: () => 'res_1' }))
+
+jest.unstable_mockModule('@ossy/event-store', () => ({
+  Aggregate: {
+    Of: ofMock,
+    View: () => (saved) => saved,
+  },
+}))
+
+jest.unstable_mockModule('@ossy/workspaces/server', () => ({
+  Workspace: { name: 'Workspace' },
+}))
+
+jest.unstable_mockModule('@ossy/resources/server', () => ({
+  ResourceStream: { Collection: { findOne } },
+  commitResource,
+  ResourcesEvents: {
+    Created ({ resourceId, schemaId, createdBy, belongsTo, location, name, access, content, ...rest }) {
+      return {
+        type: schemaId,
+        resourceId,
+        event: 'Created',
+        createdBy,
+        payload: {
+          belongsTo,
+          location,
+          name,
+          access,
+          content: content ?? {},
+          ...rest,
+        },
+      }
+    },
+  },
+}))
+
+const { run } = await import('./create-page-view.task.js')
+
+describe('create-page-view task', () => {
+  beforeEach(() => {
+    findOne.mockReset()
+    commitResource.mockReset()
+    ofMock.mockReset()
+  })
+
+  it('returns 200-shaped no-op when the Host is not registered', async () => {
+    findOne.mockResolvedValue(null)
+    const result = await run({
+      payload: { path: '/', ip: '1.2.3.4', countryCode: 'US' },
+      req: { hostname: 'unknown.example', ip: '9.9.9.9', headers: {} },
+    })
+    expect(result).toEqual({ ok: true, recorded: false })
+    expect(commitResource).not.toHaveBeenCalled()
+  })
+
+  it('returns no-op for unregistered localhost without leaking the registry', async () => {
+    findOne.mockResolvedValue(null)
+    const result = await run({
+      payload: { path: '/' },
+      req: { hostname: 'localhost', workspaceId: 'ws-cookie', headers: {} },
+    })
+    expect(result).toEqual({ ok: true, recorded: false })
+    expect(findOne).toHaveBeenCalled()
+    expect(commitResource).not.toHaveBeenCalled()
+  })
+
+  it('records a view when localhost is a registered Host', async () => {
+    findOne.mockResolvedValue({ state: { belongsTo: 'ws-local' } })
+    ofMock.mockImplementation(() => ({
+      then (fn) {
+        return Promise.resolve(fn({ id: 'ws-local' }))
+      },
+    }))
+    commitResource.mockResolvedValue({ id: 'res_1' })
+
+    const result = await run({
+      payload: { path: '/' },
+      req: { hostname: 'localhost', headers: { origin: 'http://localhost:3006' } },
+    })
+
+    expect(result).toEqual({ ok: true, recorded: true, id: 'res_1' })
+    expect(commitResource.mock.calls[0][0].payload.content.host).toBe('localhost')
+    expect(commitResource.mock.calls[0][0].payload.belongsTo).toBe('ws-local')
+  })
+
+  it('records a view for a registered Host and stores server host', async () => {
+    findOne.mockResolvedValue({ state: { belongsTo: 'ws-ossy' } })
+    ofMock.mockImplementation(() => ({
+      then (fn) {
+        return Promise.resolve(fn({ id: 'ws-ossy' }))
+      },
+    }))
+    commitResource.mockResolvedValue({ id: 'res_1' })
+
+    const result = await run({
+      payload: { path: '/pricing', visitorId: 'v1', workspaceId: 'ws-spoof', eventAt: 1 },
+      req: {
+        hostname: 'ossy.se',
+        headers: { 'user-agent': 'Mozilla' },
+      },
+    })
+
+    expect(result).toEqual({ ok: true, recorded: true, id: 'res_1' })
+    const event = commitResource.mock.calls[0][0]
+    expect(event.payload.belongsTo).toBe('ws-ossy')
+    expect(event.payload.content.host).toBe('ossy.se')
+    expect(event.payload.content.path).toBe('/pricing')
+    expect(event.payload.content.workspaceId).toBeUndefined()
+    expect(event.payload.content.eventAt).toBeUndefined()
+    expect(event.payload.name).toBe('/pricing')
+  })
+
+  it('attributes Origin host, not the API hostname', async () => {
+    findOne.mockResolvedValue({ state: { belongsTo: 'ws-customer' } })
+    ofMock.mockImplementation(() => ({
+      then (fn) {
+        return Promise.resolve(fn({ id: 'ws-customer' }))
+      },
+    }))
+    commitResource.mockResolvedValue({ id: 'res_1' })
+
+    const result = await run({
+      payload: { path: '/' },
+      req: {
+        hostname: 'ossy.se',
+        headers: { origin: 'https://www.customer.com', host: 'ossy.se' },
+      },
+    })
+
+    expect(result.recorded).toBe(true)
+    expect(commitResource.mock.calls[0][0].payload.belongsTo).toBe('ws-customer')
+    expect(commitResource.mock.calls[0][0].payload.content.host).toBe('customer.com')
+    expect(findOne).toHaveBeenCalledWith(expect.objectContaining({
+      $or: expect.arrayContaining([
+        { 'state.name': { $in: ['customer.com', 'www.customer.com'] } },
+      ]),
+    }))
+  })
+
+  it('does not write client payload countryCode/ip onto content', async () => {
+    findOne.mockResolvedValue({ state: { belongsTo: 'ws-1' } })
+    ofMock.mockImplementation(() => ({
+      then (fn) {
+        return Promise.resolve(fn({ id: 'ws-1' }))
+      },
+    }))
+    commitResource.mockResolvedValue({ id: 'res_1' })
+
+    await run({
+      payload: {
+        path: '/pricing',
+        countryCode: 'US',
+        ip: '1.2.3.4',
+      },
+      req: { hostname: 'ossy.se', ip: '203.0.113.10', headers: {} },
+    })
+
+    const content = commitResource.mock.calls[0][0].payload.content
+    expect(content).not.toHaveProperty('countryCode')
+    expect(content).not.toHaveProperty('ip')
+    expect(content.path).toBe('/pricing')
+    expect(content.host).toBe('ossy.se')
+  })
+})

package/src/en.translations.json

@@ -1,15 +1,18 @@
 {
   "analytics/home.documentTitle": "Analytics",
   "analytics.home.title": "Analytics",
-  "analytics.home.description": "Workspace insight KPIs for members, resources, and traffic.",
+  "analytics.home.description": "Unique visitors and page views for a registered domain.",
   "analytics.home.overview": "Overview",
   "analytics.home.traffic": "Traffic",
   "analytics.home.loading": "Loading analytics...",
   "analytics.home.error": "Could not load analytics data.",
-  "analytics.home.members": "Members",
-  "analytics.home.resources": "Resources",
-  "analytics.home.workspaceKpisError": "Could not load workspace KPIs.",
-  "analytics.home.totalPageViews": "Total page views (30 days)",
+  "analytics.home.empty": "Register a domain to see visitors and page views for that Host.",
+  "analytics.home.emptyEnableDomains": "Enable Domains for this workspace, then register a Host to see visitors.",
+  "analytics.home.addDomain": "Add a domain",
+  "analytics.home.enableDomains": "Enable domains",
+  "analytics.home.hostLabel": "Domain",
+  "analytics.home.uniqueVisitors": "Visitors (30 days)",
+  "analytics.home.totalPageViews": "Page views (30 days)",
   "analytics.home.trackedPages": "Tracked pages (30 days)",
   "analytics.home.daysWithTraffic": "Days with traffic",
   "analytics.home.topPaths": "Top paths",
@@ -17,18 +20,26 @@
   "analytics.home.unknownPath": "(unknown path)",
   "analytics.home.dailyPageViews": "Daily page views",
   "analytics.home.noDailyData": "No daily data yet.",
-  "analytics.home.cover.title": "See how your workspace is used",
-  "analytics.home.cover.text": "Members, resources, and page traffic — insight KPIs for the teams building on the platform.",
+  "analytics.home.locations": "Visitor locations",
+  "analytics.home.noLocationData": "No location data yet. Country is derived from visitor IPs (GeoLite2) when available — raw IPs are not shown.",
+  "analytics.home.cover.title": "See who visits your site",
+  "analytics.home.cover.text": "Unique visitors and page views for each domain you register — including people who never sign in.",
   "analytics.home.cover.ctaPrimary": "Get started free",
-  "analytics.home.features.members.title": "Members",
-  "analytics.home.features.members.text": "Track how many people are in the workspace.",
-  "analytics.home.features.resources.title": "Resources",
-  "analytics.home.features.resources.text": "See how much content and data you store.",
+  "analytics.home.features.visitors.title": "Visitors",
+  "analytics.home.features.visitors.text": "Count everyone on a registered Host — anonymous visitors and signed-in members.",
+  "analytics.home.features.paths.title": "Top paths",
+  "analytics.home.features.paths.text": "See which pages people open most over the last 30 days.",
   "analytics.home.features.traffic.title": "Traffic",
-  "analytics.home.features.traffic.text": "Page views over the last 30 days, by path and by day.",
+  "analytics.home.features.traffic.text": "Pick one domain at a time. Each Host has its own visitor, page-view, and location counts.",
   "analytics.sales.overview": "Overview",
   "analytics.sales.features": "Features",
   "analytics.sales.enable": "Enable analytics",
-  "analytics.sales.enableDescription": "Activate analytics for your workspace to view member, resource, and traffic KPIs.",
-  "analytics.sales.enableError": "Could not enable analytics. Try again or contact support."
+  "analytics.sales.enableDescription": "Activate analytics to view visitors and page views for domains you register.",
+  "analytics.sales.enableError": "Could not enable analytics. Try again or contact support.",
+  "@ossy/analytics/actions/create-page-view.label": "Create page view",
+  "@ossy/analytics/actions/create-page-view.description": "Record a page view for a registered Host",
+  "@ossy/analytics/actions/get-page-view-stats.label": "Get page view stats",
+  "@ossy/analytics/actions/get-page-view-stats.description": "Fetch visitor and page-view stats for a registered Host",
+  "@ossy/analytics/actions/get-workspace-kpis.label": "Get workspace KPIs",
+  "@ossy/analytics/actions/get-workspace-kpis.description": "Member and resource counts for the current workspace"
 }

package/src/get-page-view-stats.action.js

@@ -0,0 +1 @@
+export const metadata = { id: '@ossy/analytics/actions/get-page-view-stats', access: 'workspace' }

package/src/get-page-view-stats.task.js

@@ -0,0 +1,129 @@
+import { Aggregate, getProjection } from '@ossy/event-store'
+import { Workspace } from '@ossy/workspaces/server'
+import { ResourceStream } from '@ossy/resources/server'
+import {
+  normalizeHost,
+  workspaceIdForRegisteredHost,
+} from './resolve-page-view-workspace.js'
+import {
+  PageViewLocationProjection,
+  pageViewLocationScopeId,
+} from './page-view-location.aggregate.js'
+
+export const metadata = { id: '@ossy/analytics/tasks/get-page-view-stats' }
+
+const PAGE_VIEW_SCHEMA_ID = '@ossy/web/schema/page-view'
+const PAGE_VIEW_LOCATION = '/@ossy/analytics/page-views/'
+
+function parseMillis(input, fallback) {
+  if (input === undefined || input === null || input === '') return fallback
+  const n = Number(input)
+  if (!Number.isFinite(n) || n <= 0) return fallback
+  return n
+}
+
+/**
+ * Exported for unit tests — sum folded daily country buckets into byCountry.
+ * @param {Record<string, Record<string, number>> | undefined} byDay
+ */
+export function rollupByCountry (byDay, { from, to, countryLimit }) {
+  const fromDay = new Date(from).toISOString().slice(0, 10)
+  const toDay = new Date(to).toISOString().slice(0, 10)
+  const counts = new Map()
+  for (const [day, countries] of Object.entries(byDay ?? {})) {
+    if (day < fromDay || day > toDay) continue
+    for (const [rawCode, n] of Object.entries(countries ?? {})) {
+      const code = typeof rawCode === 'string' ? rawCode.trim().toUpperCase() : ''
+      if (!/^[A-Z]{2}$/.test(code)) continue
+      const count = Number(n)
+      if (!Number.isFinite(count) || count <= 0) continue
+      counts.set(code, (counts.get(code) ?? 0) + count)
+    }
+  }
+  return [...counts.entries()]
+    .map(([countryCode, viewsCount]) => ({ countryCode, views: viewsCount }))
+    .sort((a, b) => b.views - a.views || a.countryCode.localeCompare(b.countryCode))
+    .slice(0, countryLimit)
+}
+
+export async function run({ payload, req }) {
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  if (!workspaceId) throw Object.assign(new Error('workspaceId is required'), { status: 400 })
+
+  const host = normalizeHost(payload?.host ?? payload?.domain ?? req?.query?.host)
+  if (!host) throw Object.assign(new Error('host is required'), { status: 400 })
+
+  const workspace = await Aggregate.Of(Workspace, workspaceId).then(Aggregate.View())
+  const owner = await workspaceIdForRegisteredHost(ResourceStream.Collection, host)
+  if (owner !== workspace.id) {
+    throw Object.assign(new Error('Host not found'), { status: 404 })
+  }
+
+  const now = Date.now()
+  const defaultFrom = now - (30 * 24 * 60 * 60 * 1000)
+  const from = parseMillis(payload?.from ?? req?.query?.from, defaultFrom)
+  const to = parseMillis(payload?.to ?? req?.query?.to, now)
+  const topLimit = Math.min(Math.max(Number(payload?.limit ?? req?.query?.limit ?? 10), 1), 50)
+  // Country rollup is bounded by ISO codes (~250), not the top-paths cap.
+  const countryLimit = Math.min(
+    Math.max(Number(payload?.countryLimit ?? req?.query?.countryLimit ?? 250), 1),
+    250,
+  )
+
+  const baseMatch = {
+    type: PAGE_VIEW_SCHEMA_ID,
+    'state.status': { $ne: 'removed' },
+    'state.belongsTo': workspace.id,
+    'state.location': PAGE_VIEW_LOCATION,
+    'state.content.host': host,
+    'state.created': { $gte: from, $lte: to },
+  }
+
+  const locationScopeId = pageViewLocationScopeId(workspace.id, host)
+
+  const [dailyViews, topPaths, totals, unique, locationProjection] = await Promise.all([
+    Aggregate.Collection.aggregate([
+      { $match: baseMatch },
+      { $project: { date: { $dateToString: { format: '%Y-%m-%d', date: { $toDate: '$state.created' } } } } },
+      { $group: { _id: '$date', views: { $sum: 1 } } },
+      { $sort: { _id: 1 } },
+    ]).toArray(),
+    Aggregate.Collection.aggregate([
+      { $match: baseMatch },
+      { $group: { _id: '$state.content.path', views: { $sum: 1 } } },
+      { $sort: { views: -1 } },
+      { $limit: topLimit },
+      { $project: { _id: 0, path: '$_id', views: 1 } },
+    ]).toArray(),
+    Aggregate.Collection.aggregate([
+      { $match: baseMatch },
+      { $count: 'views' },
+    ]).toArray(),
+    Aggregate.Collection.aggregate([
+      {
+        $match: {
+          ...baseMatch,
+          'state.content.visitorId': { $exists: true, $nin: [null, ''] },
+        },
+      },
+      { $group: { _id: '$state.content.visitorId' } },
+      { $count: 'visitors' },
+    ]).toArray(),
+    locationScopeId
+      ? getProjection(locationScopeId, PageViewLocationProjection.ProjectionId)
+      : Promise.resolve(null),
+  ])
+
+  const byCountry = rollupByCountry(locationProjection?.byDay, { from, to, countryLimit })
+
+  return {
+    host,
+    from,
+    to,
+    totalViews: totals?.[0]?.views || 0,
+    uniqueVisitors: unique?.[0]?.visitors || 0,
+    dailyViews: dailyViews.map(x => ({ date: x._id, views: x.views })),
+    topPaths,
+    byCountry,
+  }
+}

package/src/get-page-view-stats.task.spec.js

@@ -0,0 +1,146 @@
+import { beforeEach, describe, expect, it, jest } from '@jest/globals'
+
+const aggregate = jest.fn()
+const ofMock = jest.fn()
+const findOne = jest.fn()
+const getProjection = jest.fn()
+
+jest.unstable_mockModule('@ossy/event-store', () => ({
+  Aggregate: {
+    Of: ofMock,
+    View: () => (saved) => saved,
+    Collection: { aggregate },
+  },
+  getProjection,
+}))
+
+jest.unstable_mockModule('@ossy/workspaces/server', () => ({
+  Workspace: { name: 'Workspace' },
+}))
+
+jest.unstable_mockModule('@ossy/resources/server', () => ({
+  ResourceStream: { Collection: { findOne } },
+}))
+
+jest.unstable_mockModule('./page-view-location.aggregate.js', () => ({
+  PageViewLocationProjection: {
+    ProjectionId: '@ossy/analytics/data/page-view-location',
+  },
+  pageViewLocationScopeId: (workspaceId, host) => `${workspaceId}:${host}`,
+}))
+
+const { run, rollupByCountry } = await import('./get-page-view-stats.task.js')
+
+function cursor (rows) {
+  return { toArray: async () => rows }
+}
+
+describe('rollupByCountry', () => {
+  const from = Date.parse('2026-09-01T00:00:00.000Z')
+  const to = Date.parse('2026-09-03T23:59:59.999Z')
+
+  it('sums folded daily country buckets in range and sorts by views', () => {
+    const byDay = {
+      '2026-08-31': { SE: 9 },
+      '2026-09-01': { SE: 1, US: 1 },
+      '2026-09-02': { SE: 1, DE: 1 },
+      '2026-09-04': { US: 5 },
+    }
+    expect(rollupByCountry(byDay, { from, to, countryLimit: 250 })).toEqual([
+      { countryCode: 'SE', views: 2 },
+      { countryCode: 'DE', views: 1 },
+      { countryCode: 'US', views: 1 },
+    ])
+  })
+
+  it('respects countryLimit', () => {
+    const byDay = {
+      '2026-09-01': { SE: 2, US: 1 },
+    }
+    expect(rollupByCountry(byDay, { from, to, countryLimit: 1 })).toEqual([
+      { countryCode: 'SE', views: 2 },
+    ])
+  })
+
+  it('returns [] when byDay is missing', () => {
+    expect(rollupByCountry(undefined, { from, to, countryLimit: 10 })).toEqual([])
+  })
+})
+
+describe('get-page-view-stats task', () => {
+  beforeEach(() => {
+    aggregate.mockReset()
+    findOne.mockReset()
+    getProjection.mockReset()
+    getProjection.mockResolvedValue({ byDay: { '2026-09-05': { SE: 2, US: 1 } } })
+    ofMock.mockImplementation(() => ({
+      then (fn) {
+        return Promise.resolve(fn({ id: 'ws-1' }))
+      },
+    }))
+  })
+
+  it('requires host', async () => {
+    await expect(run({ payload: { workspaceId: 'ws-1' }, req: {} }))
+      .rejects.toMatchObject({ message: 'host is required', status: 400 })
+  })
+
+  it('returns 404 when the Host is not registered on this workspace', async () => {
+    findOne.mockResolvedValue(null)
+    await expect(run({
+      payload: { workspaceId: 'ws-1', host: 'other.example', from: 1, to: 2 },
+      req: {},
+    })).rejects.toMatchObject({ status: 404 })
+    expect(aggregate).not.toHaveBeenCalled()
+  })
+
+  it('returns 404 when the Host belongs to another workspace', async () => {
+    findOne.mockResolvedValue({ state: { belongsTo: 'ws-other' } })
+    await expect(run({
+      payload: { workspaceId: 'ws-1', host: 'other.example', from: 1, to: 2 },
+      req: {},
+    })).rejects.toMatchObject({ status: 404, message: 'Host not found' })
+    expect(aggregate).not.toHaveBeenCalled()
+  })
+
+  it('filters unique visitors by host and rolls up byCountry from Host projection', async () => {
+    findOne.mockResolvedValue({ state: { belongsTo: 'ws-1' } })
+    aggregate
+      .mockReturnValueOnce(cursor([{ _id: '2026-09-05', views: 3 }]))
+      .mockReturnValueOnce(cursor([{ path: '/', views: 3 }]))
+      .mockReturnValueOnce(cursor([{ views: 3 }]))
+      .mockReturnValueOnce(cursor([{ visitors: 2 }]))
+
+    const result = await run({
+      payload: {
+        workspaceId: 'ws-1',
+        host: 'ossy.se',
+        from: Date.parse('2026-09-05T00:00:00.000Z'),
+        to: Date.parse('2026-09-05T23:59:59.999Z'),
+        limit: 10,
+      },
+      req: {},
+    })
+
+    expect(result.host).toBe('ossy.se')
+    expect(result.totalViews).toBe(3)
+    expect(result.uniqueVisitors).toBe(2)
+    expect(result.byCountry).toEqual([
+      { countryCode: 'SE', views: 2 },
+      { countryCode: 'US', views: 1 },
+    ])
+    expect(getProjection).toHaveBeenCalledWith(
+      'ws-1:ossy.se',
+      '@ossy/analytics/data/page-view-location',
+    )
+    const match = aggregate.mock.calls[0][0][0].$match
+    expect(match['state.content.host']).toBe('ossy.se')
+    expect(match['state.created']).toEqual({
+      $gte: Date.parse('2026-09-05T00:00:00.000Z'),
+      $lte: Date.parse('2026-09-05T23:59:59.999Z'),
+    })
+    expect(match['state.content.eventAt']).toBeUndefined()
+    expect(aggregate.mock.calls[0][0][1].$project.date.$dateToString.date.$toDate)
+      .toBe('$state.created')
+  })
+})

package/src/host-from-domain-resource.js

@@ -0,0 +1,9 @@
+/**
+ * Hostname stored on a managed-domain resource (Domains UI uses `content.Domain`).
+ */
+export function hostFromDomainResource (resource) {
+  const raw = resource?.content?.Domain || resource?.content?.domain || resource?.name || ''
+  const host = String(raw).split(':')[0].trim().toLowerCase()
+  if (!host) return ''
+  return host.replace(/^www\./, '')
+}

package/src/host-from-domain-resource.spec.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from '@jest/globals'
+import { hostFromDomainResource } from './host-from-domain-resource.js'
+
+describe('hostFromDomainResource', () => {
+  it('prefers content.Domain over name', () => {
+    expect(hostFromDomainResource({
+      name: 'ignored.example',
+      content: { Domain: 'www.Ossy.se:443' },
+    })).toBe('ossy.se')
+  })
+
+  it('falls back to name', () => {
+    expect(hostFromDomainResource({ name: 'customer.com' })).toBe('customer.com')
+  })
+})

package/src/index.js

@@ -1,2 +1,4 @@
 export { Definition } from './Definition.js'
 export { metadata as GetWorkspaceKpis } from './get-workspace-kpis.action.js'
+export { metadata as CreatePageView } from './create-page-view.action.js'
+export { metadata as GetPageViewStats } from './get-page-view-stats.action.js'

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

@@ -0,0 +1,94 @@
+import { normalizeHost } from './resolve-page-view-workspace.js'
+import { resolveCountryCodeFromIp } from './resolve-country-from-ip.js'
+
+const PAGE_VIEW_SCHEMA_ID = '@ossy/web/schema/page-view'
+
+/**
+ * Projection scope for one Host owned by a workspace (`workspaceId:host`).
+ * @param {string | null | undefined} workspaceId
+ * @param {string | null | undefined} host
+ * @returns {string | null}
+ */
+export function pageViewLocationScopeId (workspaceId, host) {
+  const workspace = typeof workspaceId === 'string' ? workspaceId.trim() : ''
+  const normalizedHost = normalizeHost(host)
+  if (!workspace || !normalizedHost) return null
+  return `${workspace}:${normalizedHost}`
+}
+
+/**
+ * ADR 0008 projection — Host page-view locations (#769 / Host traffic model).
+ *
+ * Events store connection `ip` on the eventstore row (ADR 0016). This
+ * projection maps IP → `countryCode` via MaxMind GeoLite2-Country and **folds
+ * at write** into daily country buckets (`byDay[YYYY-MM-DD][CC] = count`) so
+ * the snapshot stays bounded (days × ISO codes), not one row per navigation.
+ * Scope is per Host (`workspaceId:host`) so `/analytics` Host picker stays
+ * accurate. Day buckets use envelope `created` (not client `eventAt`).
+ * Rebuild with a new `.mmdb` still works — events keep the IPs.
+ */
+export class PageViewLocationProjection {
+
+  static kind = 'projection'
+  static ProjectionId = '@ossy/analytics/data/page-view-location'
+
+  static sources = [
+    { type: PAGE_VIEW_SCHEMA_ID, event: 'Created' },
+  ]
+
+  static scopeFromEvent (event) {
+    return pageViewLocationScopeId(
+      event.payload?.belongsTo,
+      event.payload?.content?.host,
+    )
+  }
+
+  static cacheKeys (scopeId) {
+    return [
+      `projection:${PageViewLocationProjection.ProjectionId}:${scopeId}`,
+      'action:@ossy/analytics/actions/get-page-view-stats',
+    ]
+  }
+
+  static initialState (scopeId) {
+    const sep = typeof scopeId === 'string' ? scopeId.indexOf(':') : -1
+    const workspaceId = sep > 0 ? scopeId.slice(0, sep) : scopeId
+    const host = sep > 0 ? scopeId.slice(sep + 1) : ''
+    return { workspaceId, host, byDay: {} }
+  }
+
+  /**
+   * @param {object} event
+   * @param {{ workspaceId?: string, host?: string, byDay?: Record<string, Record<string, number>> }} state
+   * @returns {Promise<{ workspaceId: string, host: string, byDay: Record<string, Record<string, number>> }>}
+   */
+  static async Apply (event, state) {
+    const workspaceId = event.payload?.belongsTo ?? state.workspaceId
+    const host = normalizeHost(event.payload?.content?.host ?? state.host)
+    const byDay = { ...(state.byDay ?? {}) }
+
+    if (!host) {
+      return { workspaceId, host, byDay }
+    }
+
+    const ip = typeof event.ip === 'string' ? event.ip : null
+    const countryCode = ip ? await resolveCountryCodeFromIp(ip) : null
+
+    const code = typeof countryCode === 'string' ? countryCode.trim().toUpperCase() : ''
+    if (!/^[A-Z]{2}$/.test(code)) {
+      return { workspaceId, host, byDay }
+    }
+
+    const at = Number(event.created)
+    const millis = Number.isFinite(at) && at > 0 ? at : Date.now()
+    const day = new Date(millis).toISOString().slice(0, 10)
+    const dayBucket = { ...(byDay[day] ?? {}) }
+    dayBucket[code] = (dayBucket[code] ?? 0) + 1
+    byDay[day] = dayBucket
+
+    return { workspaceId, host, byDay }
+  }
+}
+
+export { PageViewLocationProjection as Aggregate }
+export const id = 'analytics/data/page-view-location'