@nlabs/reaktor 1.6.3 → 1.7.0

package/lib/actions/analytics.js

@@ -0,0 +1,539 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * All rights reserved. Use is subject to the accompanying commercial LICENSE.
+ */ import { CreateAppMonitorCommand, GetAppMonitorCommand, GetAppMonitorDataCommand, RUMClient } from '@aws-sdk/client-rum';
+import { createHash, randomUUID } from 'crypto';
+import { Config } from '../config.js';
+import { COLLECTIONS } from '../constants/collections.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { UserError } from '../utils/analyticsUtils.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { isAdminUser } from '../utils/sessionUtils.js';
+import { addItem, getItemBy, getListBy, updateItem } from './crud.js';
+const MAX_APP_ID_LENGTH = 128;
+const MAX_DOMAIN_LENGTH = 253;
+const MAX_MONITOR_NAME_LENGTH = 255;
+const MAX_RUM_PAGES = 10;
+const MAX_RUM_RESULTS = 100;
+const VALID_RANGE_DAYS = new Set([
+    1,
+    7,
+    30
+]);
+const collectionInitialization = new Map();
+const normalizeText = (value, maxLength)=>String(value || '').trim().slice(0, maxLength);
+const normalizeDomain = (value)=>normalizeText(value, MAX_DOMAIN_LENGTH).replace(/^https?:\/\//i, '').split('/')[0].split(':')[0].toLowerCase();
+const normalizeMonitorName = (value, appId)=>normalizeText(value || appId, MAX_MONITOR_NAME_LENGTH).replace(/[^a-zA-Z0-9-_]/g, '-');
+const getDocumentKey = (appId)=>createHash('sha256').update(appId).digest('hex');
+const requireAdmin = (context)=>{
+    if (!isAdminUser(context.session)) {
+        throw new UserError(ErrorTypes.INVALID_SESSION);
+    }
+};
+const requireSession = (context)=>{
+    const session = context.session;
+    if (!session?.userId) {
+        throw new UserError(ErrorTypes.INVALID_SESSION);
+    }
+    return session;
+};
+const initializeAnalyticsCollection = async (databaseName)=>{
+    const cacheKey = databaseName || 'reaktor';
+    const existingInitialization = collectionInitialization.get(cacheKey);
+    if (existingInitialization) {
+        return existingInitialization;
+    }
+    const initialization = (async ()=>{
+        const database = useDb(databaseName);
+        const collection = database.collection(COLLECTIONS.ANALYTICS);
+        if (!await collection.exists()) {
+            try {
+                await database.createCollection(COLLECTIONS.ANALYTICS);
+            } catch (error) {
+                if (!await collection.exists()) {
+                    throw error;
+                }
+            }
+        }
+        await collection.ensureIndex({
+            fields: [
+                'analyticsId'
+            ],
+            type: 'persistent',
+            unique: true
+        });
+        await collection.ensureIndex({
+            fields: [
+                'appId'
+            ],
+            type: 'persistent',
+            unique: true
+        });
+    })();
+    collectionInitialization.set(cacheKey, initialization);
+    try {
+        await initialization;
+    } catch (error) {
+        collectionInitialization.delete(cacheKey);
+        throw error;
+    }
+};
+const getRumClient = (context)=>{
+    const awsConfig = context.config?.aws || Config.get('aws', {});
+    const { accessKeyId, secretAccessKey, sessionToken } = awsConfig.credentials || {};
+    const usesRuntimeCredentials = Boolean(process.env.AWS_SESSION_TOKEN && accessKeyId === process.env.AWS_ACCESS_KEY_ID && secretAccessKey === process.env.AWS_SECRET_ACCESS_KEY);
+    const credentials = accessKeyId && secretAccessKey && !usesRuntimeCredentials ? {
+        accessKeyId,
+        secretAccessKey,
+        ...sessionToken ? {
+            sessionToken
+        } : {}
+    } : undefined;
+    return new RUMClient({
+        ...credentials ? {
+            credentials
+        } : {},
+        ...awsConfig.region ? {
+            region: awsConfig.region
+        } : {}
+    });
+};
+const findAwsMonitor = async (client, monitorName)=>{
+    try {
+        const response = await client.send(new GetAppMonitorCommand({
+            Name: monitorName
+        }));
+        const monitorId = normalizeText(response.AppMonitor?.Id, 36);
+        return monitorId ? {
+            domain: normalizeDomain(response.AppMonitor?.Domain),
+            id: monitorId,
+            name: normalizeText(response.AppMonitor?.Name || monitorName, MAX_MONITOR_NAME_LENGTH)
+        } : null;
+    } catch (error) {
+        if (error.name === 'ResourceNotFoundException') {
+            return null;
+        }
+        throw error;
+    }
+};
+const findOrCreateAwsMonitor = async (context, appId, domain, monitorName)=>{
+    const client = getRumClient(context);
+    const existingMonitor = await findAwsMonitor(client, monitorName);
+    if (existingMonitor) {
+        return {
+            domain: existingMonitor.domain || domain,
+            id: existingMonitor.id,
+            name: existingMonitor.name
+        };
+    }
+    const response = await client.send(new CreateAppMonitorCommand({
+        CustomEvents: {
+            Status: 'ENABLED'
+        },
+        CwLogEnabled: false,
+        Domain: domain,
+        Name: monitorName,
+        Platform: 'Web',
+        Tags: {
+            appId,
+            managedBy: 'reaktor'
+        }
+    }));
+    const monitorId = normalizeText(response.Id, 36);
+    if (!monitorId) {
+        throw new UserError('invalid_rum_monitor');
+    }
+    return {
+        domain,
+        id: monitorId,
+        name: monitorName
+    };
+};
+const parseMonitorInput = (input)=>{
+    const appId = normalizeText(input?.appId, MAX_APP_ID_LENGTH);
+    const appName = normalizeText(input?.appName || input?.monitorName || appId, MAX_MONITOR_NAME_LENGTH);
+    const domain = normalizeDomain(input?.domain);
+    const monitorName = normalizeMonitorName(input?.monitorName, appId);
+    if (!appId || !domain || !monitorName) {
+        throw new UserError(ErrorTypes.INVALID_ARGUMENTS);
+    }
+    return {
+        appId,
+        appName,
+        domain,
+        monitorName
+    };
+};
+export const getAnalyticsByAppId = async (context, appIdInput)=>{
+    requireAdmin(context);
+    const appId = normalizeText(appIdInput, MAX_APP_ID_LENGTH);
+    if (!appId) {
+        throw new UserError(ErrorTypes.INVALID_ARGUMENTS);
+    }
+    await initializeAnalyticsCollection(context.databaseName);
+    return getItemBy(context, COLLECTIONS.ANALYTICS, {
+        appId
+    });
+};
+export const getAnalyticsConfiguration = async (context, appIdInput)=>{
+    const appId = normalizeText(appIdInput, MAX_APP_ID_LENGTH);
+    if (!appId) {
+        throw new UserError(ErrorTypes.INVALID_ARGUMENTS);
+    }
+    await initializeAnalyticsCollection(context.databaseName);
+    const analytics = await getItemBy(context, COLLECTIONS.ANALYTICS, {
+        appId
+    });
+    return analytics ? {
+        analyticsId: analytics.analyticsId,
+        appId: analytics.appId
+    } : null;
+};
+export const getAnalyticsById = async (context, analyticsIdInput)=>{
+    const analyticsId = normalizeText(analyticsIdInput, 36);
+    if (!analyticsId) {
+        return null;
+    }
+    await initializeAnalyticsCollection(context.databaseName);
+    return getItemBy(context, COLLECTIONS.ANALYTICS, {
+        analyticsId
+    });
+};
+export const createAnalyticsMonitor = async (context, input)=>{
+    const session = requireSession(context);
+    const { appId, appName, domain, monitorName } = parseMonitorInput(input);
+    await initializeAnalyticsCollection(context.databaseName);
+    const existing = await getItemBy(context, COLLECTIONS.ANALYTICS, {
+        appId
+    });
+    if (existing) {
+        if (isAdminUser(session) || (existing.userIds || []).includes(session.userId)) {
+            return existing;
+        }
+        throw new UserError(ErrorTypes.INVALID_SESSION);
+    }
+    const monitor = await findOrCreateAwsMonitor(context, appId, domain, monitorName);
+    return addItem(context, COLLECTIONS.ANALYTICS, {
+        _key: getDocumentKey(appId),
+        analyticsId: randomUUID(),
+        appId,
+        appName,
+        domain: monitor.domain,
+        monitorId: monitor.id,
+        monitorName: monitor.name,
+        userIds: [
+            session.userId
+        ]
+    });
+};
+export const regenerateAnalyticsId = async (context, analyticsIdInput)=>{
+    const session = requireSession(context);
+    const analyticsId = normalizeText(analyticsIdInput, 36);
+    if (!analyticsId) {
+        throw new UserError(ErrorTypes.INVALID_ARGUMENTS);
+    }
+    await initializeAnalyticsCollection(context.databaseName);
+    const existing = await getItemBy(context, COLLECTIONS.ANALYTICS, {
+        analyticsId
+    });
+    const hasAccess = existing && (isAdminUser(session) || (existing.userIds || []).includes(session.userId));
+    if (!existing?._key || !hasAccess) {
+        throw new UserError('invalid_rum_app');
+    }
+    return updateItem(context, COLLECTIONS.ANALYTICS, existing._key, {
+        analyticsId: randomUUID()
+    });
+};
+const parseJsonRecord = (value)=>{
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    } catch  {
+        return {};
+    }
+};
+const getProperty = (properties, metadata, aliases)=>{
+    const normalizedAliases = new Set(aliases.map((alias)=>alias.toLowerCase().replace(/[^a-z0-9]/g, '')));
+    const entries = [
+        ...Object.entries(properties),
+        ...Object.entries(metadata)
+    ];
+    return entries.find(([key])=>normalizedAliases.has(key.toLowerCase().replace(/[^a-z0-9]/g, '')))?.[1];
+};
+const normalizeRumEvent = (rawEvent)=>{
+    try {
+        const source = JSON.parse(rawEvent);
+        const details = parseJsonRecord(source.event_details);
+        const metadata = parseJsonRecord(source.metadata);
+        const properties = parseJsonRecord(details.properties);
+        const timestamp = Number(source.event_timestamp || 0);
+        if (!Number.isFinite(timestamp) || timestamp <= 0) {
+            return null;
+        }
+        const getText = (aliases, fallback = '')=>normalizeText(getProperty(properties, metadata, aliases) ?? fallback, 256);
+        const durationValue = Number(getProperty(properties, metadata, [
+            'duration',
+            'durationMs',
+            'latency',
+            'loadTime',
+            'pageLoadTime'
+        ]) || 0);
+        const path = normalizeText(details.path, 256);
+        const type = normalizeText(source.event_type, 256);
+        return {
+            appId: normalizeText(details.appId || metadata.applicationId, MAX_APP_ID_LENGTH),
+            browserLanguage: getText([
+                'browserLanguage'
+            ], 'Unknown'),
+            browserName: getText([
+                'browserName'
+            ], 'Unknown'),
+            browserVersion: getText([
+                'browserVersion'
+            ]),
+            deviceType: getText([
+                'deviceType'
+            ], 'Unknown'),
+            duration: Number.isFinite(durationValue) && durationValue > 0 ? durationValue : 0,
+            eventId: normalizeText(source.event_id, 128),
+            interaction: getText([
+                'interaction'
+            ], normalizeText(details.name || type, 128)),
+            name: normalizeText(details.name || type, 128),
+            osName: getText([
+                'osName'
+            ], 'Unknown'),
+            osVersion: getText([
+                'osVersion'
+            ]),
+            outcome: getText([
+                'outcome'
+            ]),
+            pageId: getText([
+                'pageId',
+                'pageID'
+            ], path || 'Unknown'),
+            parentPage: getText([
+                'parentPageId',
+                'parentPage'
+            ]),
+            path,
+            sessionId: normalizeText(source.sessionId || parseJsonRecord(source.user_details).sessionId, 128),
+            timestamp,
+            type,
+            viewId: getText([
+                'viewId'
+            ])
+        };
+    } catch  {
+        return null;
+    }
+};
+const createBreakdown = (values, total)=>{
+    const counts = values.reduce((result, value)=>{
+        const label = value || 'Unknown';
+        result.set(label, (result.get(label) || 0) + 1);
+        return result;
+    }, new Map());
+    return Array.from(counts, ([label, count])=>({
+            count,
+            label,
+            percentage: total > 0 ? Math.round(count / total * 1000) / 10 : 0
+        })).sort((left, right)=>right.count - left.count || left.label.localeCompare(right.label));
+};
+const percentile = (values, percentileValue)=>{
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = values.toSorted((left, right)=>left - right);
+    const index = Math.max(0, Math.ceil(percentileValue * sorted.length) - 1);
+    return sorted[index];
+};
+const createViewPerformance = (events)=>{
+    const views = events.reduce((result, event)=>{
+        if (event.type !== 'view_performance' && event.name !== 'view_performance' || !event.viewId || event.outcome === 'cancelled') {
+            return result;
+        }
+        const samples = result.get(event.viewId) || [];
+        samples.push(event);
+        result.set(event.viewId, samples);
+        return result;
+    }, new Map());
+    return Array.from(views, ([viewId, samples])=>{
+        const durations = samples.map((event)=>event.duration);
+        const percentage = (outcome)=>Math.round(samples.filter((event)=>event.outcome === outcome).length / samples.length * 1000) / 10;
+        return {
+            failureRate: percentage('failure'),
+            p50: percentile(durations, 0.5),
+            p75: percentile(durations, 0.75),
+            p95: percentile(durations, 0.95),
+            sampleCount: samples.length,
+            timeoutRate: percentage('timeout'),
+            viewId
+        };
+    }).sort((left, right)=>right.sampleCount - left.sampleCount || left.viewId.localeCompare(right.viewId));
+};
+const getAuthorizedAnalytics = async (context, analyticsId)=>{
+    const session = requireSession(context);
+    const analytics = await getAnalyticsById(context, analyticsId);
+    const hasAccess = analytics && (isAdminUser(session) || (analytics.userIds || []).includes(session.userId));
+    if (!analytics || !hasAccess) {
+        throw new UserError(ErrorTypes.INVALID_SESSION);
+    }
+    return analytics;
+};
+const getAnalyticsAppName = async (context, analytics)=>{
+    if (analytics.appName) {
+        return analytics.appName;
+    }
+    const app = await getItemBy(context, COLLECTIONS.APPS, {
+        conditions: [
+            {
+                field: 'appId',
+                operator: '==',
+                value: analytics.appId
+            },
+            {
+                field: '_key',
+                operator: '==',
+                value: analytics.appId
+            }
+        ],
+        logic: 'OR'
+    });
+    return normalizeText(app?.displayName || app?.name || analytics.monitorName || analytics.appId, MAX_MONITOR_NAME_LENGTH);
+};
+export const getAvailableAnalytics = async (context)=>{
+    const session = requireSession(context);
+    await initializeAnalyticsCollection(context.databaseName);
+    const analytics = await getListBy(context, COLLECTIONS.ANALYTICS, {}, {
+        sort: [
+            {
+                direction: 'ASC',
+                field: 'appName'
+            }
+        ]
+    });
+    const available = analytics.filter((item)=>isAdminUser(session) || (item.userIds || []).includes(session.userId));
+    const enriched = await Promise.all(available.map(async (item)=>({
+            ...item,
+            appName: await getAnalyticsAppName(context, item),
+            userIds: item.userIds || []
+        })));
+    return enriched.sort((left, right)=>(left.appName || '').localeCompare(right.appName || ''));
+};
+export const setAnalyticsAccess = async (context, analyticsIdInput, userIdsInput)=>{
+    requireAdmin(context);
+    const analyticsId = normalizeText(analyticsIdInput, 36);
+    const analytics = await getAnalyticsById(context, analyticsId);
+    if (!analytics?._key) {
+        throw new UserError('invalid_rum_app');
+    }
+    const userIds = Array.from(new Set((userIdsInput || []).map((userId)=>normalizeText(userId, 128)).filter(Boolean))).slice(0, 100);
+    return updateItem(context, COLLECTIONS.ANALYTICS, analytics._key, {
+        userIds
+    });
+};
+export const getAnalyticsDashboard = async (context, analyticsIdInput, rangeDaysInput)=>{
+    const analyticsId = normalizeText(analyticsIdInput, 36);
+    const rangeDays = Math.floor(Number(rangeDaysInput));
+    if (!analyticsId || !VALID_RANGE_DAYS.has(rangeDays)) {
+        throw new UserError(ErrorTypes.INVALID_ARGUMENTS);
+    }
+    const analytics = await getAuthorizedAnalytics(context, analyticsId);
+    const endTime = Date.now();
+    const startTime = endTime - rangeDays * 24 * 60 * 60 * 1000 + (rangeDays === 30 ? 60_000 : 0);
+    const client = getRumClient(context);
+    const rawEvents = [];
+    let nextToken;
+    let page = 0;
+    do {
+        const response = await client.send(new GetAppMonitorDataCommand({
+            MaxResults: MAX_RUM_RESULTS,
+            Name: analytics.monitorName,
+            ...nextToken ? {
+                NextToken: nextToken
+            } : {},
+            TimeRange: {
+                After: startTime,
+                Before: endTime
+            }
+        }));
+        rawEvents.push(...response.Events || []);
+        nextToken = response.NextToken;
+        page += 1;
+    }while (nextToken && page < MAX_RUM_PAGES)
+    const events = rawEvents.map(normalizeRumEvent).filter((event)=>Boolean(event && event.appId === analytics.appId)).sort((left, right)=>right.timestamp - left.timestamp);
+    const sessions = new Set(events.map((event)=>event.sessionId).filter(Boolean));
+    const interactionEvents = events.filter((event)=>event.type !== 'page_view' && event.type !== 'view_performance');
+    const errorEvents = events.filter((event)=>/error|exception|failure/i.test(`${event.type} ${event.name}`));
+    const durations = events.map((event)=>event.duration).filter((duration)=>duration > 0);
+    const bucketSize = rangeDays === 1 ? 60 * 60 * 1000 : 24 * 60 * 60 * 1000;
+    const buckets = new Map();
+    for(let timestamp = Math.floor(startTime / bucketSize) * bucketSize; timestamp <= endTime; timestamp += bucketSize){
+        buckets.set(timestamp, {
+            errors: 0,
+            events: 0,
+            interactions: 0,
+            sessions: new Set()
+        });
+    }
+    events.forEach((event)=>{
+        const bucket = buckets.get(Math.floor(event.timestamp / bucketSize) * bucketSize);
+        if (!bucket) {
+            return;
+        }
+        bucket.events += 1;
+        bucket.interactions += event.type === 'page_view' || event.type === 'view_performance' ? 0 : 1;
+        bucket.errors += /error|exception|failure/i.test(`${event.type} ${event.name}`) ? 1 : 0;
+        if (event.sessionId) {
+            bucket.sessions.add(event.sessionId);
+        }
+    });
+    return {
+        analyticsId: analytics.analyticsId,
+        appId: analytics.appId,
+        appName: await getAnalyticsAppName(context, analytics),
+        averageDuration: durations.length ? Math.round(durations.reduce((total, duration)=>total + duration, 0) / durations.length) : 0,
+        browsers: createBreakdown(events.map((event)=>[
+                event.browserName,
+                event.browserVersion
+            ].filter(Boolean).join(' ')), events.length),
+        devices: createBreakdown(events.map((event)=>event.deviceType), events.length),
+        endTime,
+        errorCount: errorEvents.length,
+        eventCount: events.length,
+        generatedAt: Date.now(),
+        interactions: createBreakdown(interactionEvents.map((event)=>event.interaction || event.name), interactionEvents.length),
+        languages: createBreakdown(events.map((event)=>event.browserLanguage), events.length),
+        monitorId: analytics.monitorId,
+        monitorName: analytics.monitorName,
+        operatingSystems: createBreakdown(events.map((event)=>[
+                event.osName,
+                event.osVersion
+            ].filter(Boolean).join(' ')), events.length),
+        pages: createBreakdown(events.map((event)=>event.pageId || event.path), events.length),
+        pageViewCount: events.filter((event)=>event.type === 'page_view').length,
+        partial: Boolean(nextToken),
+        performanceSamples: durations.length,
+        recentEvents: events.slice(0, 100).map(({ appId: _appId, ...event })=>event),
+        sessionCount: sessions.size,
+        startTime,
+        timeline: Array.from(buckets, ([timestamp, bucket])=>({
+                errors: bucket.errors,
+                events: bucket.events,
+                interactions: bucket.interactions,
+                sessions: bucket.sessions.size,
+                timestamp
+            })),
+        viewPerformance: createViewPerformance(events)
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/private/tmp/nlabs-reaktor-release.eMQ5Sh/checkout/packages/reaktor/src/actions/analytics.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {\n  CreateAppMonitorCommand,\n  GetAppMonitorCommand,\n  GetAppMonitorDataCommand,\n  RUMClient\n} from '@aws-sdk/client-rum';\nimport {createHash, randomUUID} from 'crypto';\n\nimport {Config} from '../config.js';\nimport {COLLECTIONS} from '../constants/collections.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {UserError} from '../utils/analyticsUtils.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {isAdminUser} from '../utils/sessionUtils.js';\nimport {addItem, getItemBy, getListBy, updateItem} from './crud.js';\n\nimport type {AwsConfig} from '../config.js';\nimport type {AppType} from '../types/apps.types.js';\nimport type {\n  AnalyticsConfigurationType,\n  AnalyticsDashboardType,\n  AnalyticsEventType,\n  AnalyticsType,\n  CreateAnalyticsMonitorInputType\n} from '../types/analytics.types.js';\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {Session} from '../utils/sessionUtils.js';\n\nconst MAX_APP_ID_LENGTH = 128;\nconst MAX_DOMAIN_LENGTH = 253;\nconst MAX_MONITOR_NAME_LENGTH = 255;\nconst MAX_RUM_PAGES = 10;\nconst MAX_RUM_RESULTS = 100;\nconst VALID_RANGE_DAYS = new Set([1, 7, 30]);\nconst collectionInitialization = new Map<string, Promise<void>>();\n\nconst normalizeText = (value: unknown, maxLength: number): string =>\n  String(value || '').trim().slice(0, maxLength);\n\nconst normalizeDomain = (value: unknown): string => normalizeText(value, MAX_DOMAIN_LENGTH)\n  .replace(/^https?:\\/\\//i, '')\n  .split('/')[0]\n  .split(':')[0]\n  .toLowerCase();\n\nconst normalizeMonitorName = (value: unknown, appId: string): string =>\n  normalizeText(value || appId, MAX_MONITOR_NAME_LENGTH).replace(/[^a-zA-Z0-9-_]/g, '-');\n\nconst getDocumentKey = (appId: string): string =>\n  createHash('sha256').update(appId).digest('hex');\n\nconst requireAdmin = (context: ApiContext): void => {\n  if(!isAdminUser(context.session as Session)) {\n    throw new UserError(ErrorTypes.INVALID_SESSION);\n  }\n};\n\nconst requireSession = (context: ApiContext): Session => {\n  const session = context.session as Session;\n\n  if(!session?.userId) {\n    throw new UserError(ErrorTypes.INVALID_SESSION);\n  }\n\n  return session;\n};\n\nconst initializeAnalyticsCollection = async (databaseName?: string): Promise<void> => {\n  const cacheKey = databaseName || 'reaktor';\n  const existingInitialization = collectionInitialization.get(cacheKey);\n\n  if(existingInitialization) {\n    return existingInitialization;\n  }\n\n  const initialization = (async () => {\n    const database = useDb(databaseName);\n    const collection = database.collection(COLLECTIONS.ANALYTICS);\n\n    if(!await collection.exists()) {\n      try {\n        await database.createCollection(COLLECTIONS.ANALYTICS);\n      } catch(error) {\n        if(!await collection.exists()) {\n          throw error;\n        }\n      }\n    }\n\n    await collection.ensureIndex({fields: ['analyticsId'], type: 'persistent', unique: true});\n    await collection.ensureIndex({fields: ['appId'], type: 'persistent', unique: true});\n  })();\n\n  collectionInitialization.set(cacheKey, initialization);\n\n  try {\n    await initialization;\n  } catch(error) {\n    collectionInitialization.delete(cacheKey);\n    throw error;\n  }\n};\n\nconst getRumClient = (context: ApiContext): RUMClient => {\n  const awsConfig: AwsConfig = context.config?.aws || Config.get<AwsConfig>('aws', {});\n  const {accessKeyId, secretAccessKey, sessionToken} = awsConfig.credentials || {};\n  const usesRuntimeCredentials = Boolean(\n    process.env.AWS_SESSION_TOKEN &&\n    accessKeyId === process.env.AWS_ACCESS_KEY_ID &&\n    secretAccessKey === process.env.AWS_SECRET_ACCESS_KEY\n  );\n  const credentials = accessKeyId && secretAccessKey && !usesRuntimeCredentials ? {\n    accessKeyId,\n    secretAccessKey,\n    ...(sessionToken ? {sessionToken} : {})\n  } : undefined;\n\n  return new RUMClient({\n    ...(credentials ? {credentials} : {}),\n    ...(awsConfig.region ? {region: awsConfig.region} : {})\n  });\n};\n\nconst findAwsMonitor = async (\n  client: RUMClient,\n  monitorName: string\n): Promise<{domain?: string; id: string; name: string} | null> => {\n  try {\n    const response = await client.send(new GetAppMonitorCommand({Name: monitorName}));\n    const monitorId = normalizeText(response.AppMonitor?.Id, 36);\n\n    return monitorId ? {\n      domain: normalizeDomain(response.AppMonitor?.Domain),\n      id: monitorId,\n      name: normalizeText(response.AppMonitor?.Name || monitorName, MAX_MONITOR_NAME_LENGTH)\n    } : null;\n  } catch(error) {\n    if((error as {name?: string}).name === 'ResourceNotFoundException') {\n      return null;\n    }\n\n    throw error;\n  }\n};\n\nconst findOrCreateAwsMonitor = async (\n  context: ApiContext,\n  appId: string,\n  domain: string,\n  monitorName: string\n): Promise<{domain: string; id: string; name: string}> => {\n  const client = getRumClient(context);\n  const existingMonitor = await findAwsMonitor(client, monitorName);\n\n  if(existingMonitor) {\n    return {\n      domain: existingMonitor.domain || domain,\n      id: existingMonitor.id,\n      name: existingMonitor.name\n    };\n  }\n\n  const response = await client.send(new CreateAppMonitorCommand({\n    CustomEvents: {Status: 'ENABLED'},\n    CwLogEnabled: false,\n    Domain: domain,\n    Name: monitorName,\n    Platform: 'Web',\n    Tags: {appId, managedBy: 'reaktor'}\n  }));\n  const monitorId = normalizeText(response.Id, 36);\n\n  if(!monitorId) {\n    throw new UserError('invalid_rum_monitor');\n  }\n\n  return {domain, id: monitorId, name: monitorName};\n};\n\nconst parseMonitorInput = (\n  input: CreateAnalyticsMonitorInputType\n): {appId: string; appName: string; domain: string; monitorName: string} => {\n  const appId = normalizeText(input?.appId, MAX_APP_ID_LENGTH);\n  const appName = normalizeText(input?.appName || input?.monitorName || appId, MAX_MONITOR_NAME_LENGTH);\n  const domain = normalizeDomain(input?.domain);\n  const monitorName = normalizeMonitorName(input?.monitorName, appId);\n\n  if(!appId || !domain || !monitorName) {\n    throw new UserError(ErrorTypes.INVALID_ARGUMENTS);\n  }\n\n  return {appId, appName, domain, monitorName};\n};\n\nexport const getAnalyticsByAppId = async (\n  context: ApiContext,\n  appIdInput: string\n): Promise<AnalyticsType | null> => {\n  requireAdmin(context);\n  const appId = normalizeText(appIdInput, MAX_APP_ID_LENGTH);\n\n  if(!appId) {\n    throw new UserError(ErrorTypes.INVALID_ARGUMENTS);\n  }\n\n  await initializeAnalyticsCollection(context.databaseName);\n  return getItemBy<AnalyticsType>(context, COLLECTIONS.ANALYTICS, {appId});\n};\n\nexport const getAnalyticsConfiguration = async (\n  context: ApiContext,\n  appIdInput: string\n): Promise<AnalyticsConfigurationType | null> => {\n  const appId = normalizeText(appIdInput, MAX_APP_ID_LENGTH);\n\n  if(!appId) {\n    throw new UserError(ErrorTypes.INVALID_ARGUMENTS);\n  }\n\n  await initializeAnalyticsCollection(context.databaseName);\n  const analytics = await getItemBy<AnalyticsType>(context, COLLECTIONS.ANALYTICS, {appId});\n\n  return analytics ? {analyticsId: analytics.analyticsId, appId: analytics.appId} : null;\n};\n\nexport const getAnalyticsById = async (\n  context: ApiContext,\n  analyticsIdInput: string\n): Promise<AnalyticsType | null> => {\n  const analyticsId = normalizeText(analyticsIdInput, 36);\n\n  if(!analyticsId) {\n    return null;\n  }\n\n  await initializeAnalyticsCollection(context.databaseName);\n  return getItemBy<AnalyticsType>(context, COLLECTIONS.ANALYTICS, {analyticsId});\n};\n\nexport const createAnalyticsMonitor = async (\n  context: ApiContext,\n  input: CreateAnalyticsMonitorInputType\n): Promise<AnalyticsType> => {\n  const session = requireSession(context);\n  const {appId, appName, domain, monitorName} = parseMonitorInput(input);\n  await initializeAnalyticsCollection(context.databaseName);\n  const existing = await getItemBy<AnalyticsType>(context, COLLECTIONS.ANALYTICS, {appId});\n\n  if(existing) {\n    if(isAdminUser(session) || (existing.userIds || []).includes(session.userId)) {\n      return existing;\n    }\n\n    throw new UserError(ErrorTypes.INVALID_SESSION);\n  }\n\n  const monitor = await findOrCreateAwsMonitor(context, appId, domain, monitorName);\n  return addItem<AnalyticsType>(context, COLLECTIONS.ANALYTICS, {\n    _key: getDocumentKey(appId),\n    analyticsId: randomUUID(),\n    appId,\n    appName,\n    domain: monitor.domain,\n    monitorId: monitor.id,\n    monitorName: monitor.name,\n    userIds: [session.userId]\n  });\n};\n\nexport const regenerateAnalyticsId = async (\n  context: ApiContext,\n  analyticsIdInput: string\n): Promise<AnalyticsType> => {\n  const session = requireSession(context);\n  const analyticsId = normalizeText(analyticsIdInput, 36);\n\n  if(!analyticsId) {\n    throw new UserError(ErrorTypes.INVALID_ARGUMENTS);\n  }\n\n  await initializeAnalyticsCollection(context.databaseName);\n  const existing = await getItemBy<AnalyticsType>(context, COLLECTIONS.ANALYTICS, {analyticsId});\n  const hasAccess = existing && (\n    isAdminUser(session) || (existing.userIds || []).includes(session.userId)\n  );\n\n  if(!existing?._key || !hasAccess) {\n    throw new UserError('invalid_rum_app');\n  }\n\n  return updateItem<AnalyticsType>(\n    context,\n    COLLECTIONS.ANALYTICS,\n    existing._key,\n    {analyticsId: randomUUID()}\n  );\n};\n\ntype AwsRumRecord = Record<string, unknown> & {\n  event_details?: unknown;\n  metadata?: unknown;\n};\n\ntype NormalizedRumEvent = AnalyticsEventType & {readonly appId: string};\n\nconst parseJsonRecord = (value: unknown): Record<string, unknown> => {\n  if(value && typeof value === 'object' && !Array.isArray(value)) {\n    return value as Record<string, unknown>;\n  }\n\n  if(typeof value !== 'string') {\n    return {};\n  }\n\n  try {\n    const parsed = JSON.parse(value);\n    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)\n      ? parsed as Record<string, unknown>\n      : {};\n  } catch {\n    return {};\n  }\n};\n\nconst getProperty = (\n  properties: Record<string, unknown>,\n  metadata: Record<string, unknown>,\n  aliases: readonly string[]\n): unknown => {\n  const normalizedAliases = new Set(aliases.map((alias) => alias.toLowerCase().replace(/[^a-z0-9]/g, '')));\n  const entries = [...Object.entries(properties), ...Object.entries(metadata)];\n  return entries.find(([key]) => normalizedAliases.has(key.toLowerCase().replace(/[^a-z0-9]/g, '')))?.[1];\n};\n\nconst normalizeRumEvent = (rawEvent: string): NormalizedRumEvent | null => {\n  try {\n    const source = JSON.parse(rawEvent) as AwsRumRecord;\n    const details = parseJsonRecord(source.event_details);\n    const metadata = parseJsonRecord(source.metadata);\n    const properties = parseJsonRecord(details.properties);\n    const timestamp = Number(source.event_timestamp || 0);\n\n    if(!Number.isFinite(timestamp) || timestamp <= 0) {\n      return null;\n    }\n\n    const getText = (aliases: readonly string[], fallback = ''): string =>\n      normalizeText(getProperty(properties, metadata, aliases) ?? fallback, 256);\n    const durationValue = Number(getProperty(properties, metadata, [\n      'duration',\n      'durationMs',\n      'latency',\n      'loadTime',\n      'pageLoadTime'\n    ]) || 0);\n    const path = normalizeText(details.path, 256);\n    const type = normalizeText(source.event_type, 256);\n\n    return {\n      appId: normalizeText(details.appId || metadata.applicationId, MAX_APP_ID_LENGTH),\n      browserLanguage: getText(['browserLanguage'], 'Unknown'),\n      browserName: getText(['browserName'], 'Unknown'),\n      browserVersion: getText(['browserVersion']),\n      deviceType: getText(['deviceType'], 'Unknown'),\n      duration: Number.isFinite(durationValue) && durationValue > 0 ? durationValue : 0,\n      eventId: normalizeText(source.event_id, 128),\n      interaction: getText(['interaction'], normalizeText(details.name || type, 128)),\n      name: normalizeText(details.name || type, 128),\n      osName: getText(['osName'], 'Unknown'),\n      osVersion: getText(['osVersion']),\n      outcome: getText(['outcome']),\n      pageId: getText(['pageId', 'pageID'], path || 'Unknown'),\n      parentPage: getText(['parentPageId', 'parentPage']),\n      path,\n      sessionId: normalizeText(source.sessionId || parseJsonRecord(source.user_details).sessionId, 128),\n      timestamp,\n      type,\n      viewId: getText(['viewId'])\n    };\n  } catch {\n    return null;\n  }\n};\n\nconst createBreakdown = (values: readonly string[], total: number) => {\n  const counts = values.reduce<Map<string, number>>((result, value) => {\n    const label = value || 'Unknown';\n    result.set(label, (result.get(label) || 0) + 1);\n    return result;\n  }, new Map());\n\n  return Array.from(counts, ([label, count]) => ({\n    count,\n    label,\n    percentage: total > 0 ? Math.round((count / total) * 1000) / 10 : 0\n  })).sort((left, right) => right.count - left.count || left.label.localeCompare(right.label));\n};\n\nconst percentile = (values: readonly number[], percentileValue: number): number => {\n  if(values.length === 0) {\n    return 0;\n  }\n\n  const sorted = values.toSorted((left, right) => left - right);\n  const index = Math.max(0, Math.ceil(percentileValue * sorted.length) - 1);\n  return sorted[index];\n};\n\nconst createViewPerformance = (events: readonly NormalizedRumEvent[]) => {\n  const views = events.reduce<Map<string, NormalizedRumEvent[]>>((result, event) => {\n    if(\n      (event.type !== 'view_performance' && event.name !== 'view_performance')\n      || !event.viewId\n      || event.outcome === 'cancelled'\n    ) {\n      return result;\n    }\n\n    const samples = result.get(event.viewId) || [];\n    samples.push(event);\n    result.set(event.viewId, samples);\n    return result;\n  }, new Map());\n\n  return Array.from(views, ([viewId, samples]) => {\n    const durations = samples.map((event) => event.duration);\n    const percentage = (outcome: string): number => Math.round(\n      (samples.filter((event) => event.outcome === outcome).length / samples.length) * 1000\n    ) / 10;\n\n    return {\n      failureRate: percentage('failure'),\n      p50: percentile(durations, 0.5),\n      p75: percentile(durations, 0.75),\n      p95: percentile(durations, 0.95),\n      sampleCount: samples.length,\n      timeoutRate: percentage('timeout'),\n      viewId\n    };\n  }).sort((left, right) => right.sampleCount - left.sampleCount || left.viewId.localeCompare(right.viewId));\n};\n\nconst getAuthorizedAnalytics = async (\n  context: ApiContext,\n  analyticsId: string\n): Promise<AnalyticsType> => {\n  const session = requireSession(context);\n  const analytics = await getAnalyticsById(context, analyticsId);\n  const hasAccess = analytics && (\n    isAdminUser(session) || (analytics.userIds || []).includes(session.userId)\n  );\n\n  if(!analytics || !hasAccess) {\n    throw new UserError(ErrorTypes.INVALID_SESSION);\n  }\n\n  return analytics;\n};\n\nconst getAnalyticsAppName = async (context: ApiContext, analytics: AnalyticsType): Promise<string> => {\n  if(analytics.appName) {\n    return analytics.appName;\n  }\n\n  const app = await getItemBy<AppType>(context, COLLECTIONS.APPS, {\n    conditions: [\n      {field: 'appId', operator: '==', value: analytics.appId},\n      {field: '_key', operator: '==', value: analytics.appId}\n    ],\n    logic: 'OR'\n  });\n\n  return normalizeText(app?.displayName || app?.name || analytics.monitorName || analytics.appId, MAX_MONITOR_NAME_LENGTH);\n};\n\nexport const getAvailableAnalytics = async (context: ApiContext): Promise<AnalyticsType[]> => {\n  const session = requireSession(context);\n  await initializeAnalyticsCollection(context.databaseName);\n  const analytics = await getListBy<AnalyticsType>(context, COLLECTIONS.ANALYTICS, {}, {\n    sort: [{direction: 'ASC', field: 'appName'}]\n  });\n\n  const available = analytics.filter((item) =>\n    isAdminUser(session) || (item.userIds || []).includes(session.userId));\n\n  const enriched = await Promise.all(available.map(async (item) => ({\n    ...item,\n    appName: await getAnalyticsAppName(context, item),\n    userIds: item.userIds || []\n  })));\n\n  return enriched.sort((left, right) =>\n    (left.appName || '').localeCompare(right.appName || ''));\n};\n\nexport const setAnalyticsAccess = async (\n  context: ApiContext,\n  analyticsIdInput: string,\n  userIdsInput: readonly string[]\n): Promise<AnalyticsType> => {\n  requireAdmin(context);\n  const analyticsId = normalizeText(analyticsIdInput, 36);\n  const analytics = await getAnalyticsById(context, analyticsId);\n\n  if(!analytics?._key) {\n    throw new UserError('invalid_rum_app');\n  }\n\n  const userIds = Array.from(new Set((userIdsInput || [])\n    .map((userId) => normalizeText(userId, 128))\n    .filter(Boolean)))\n    .slice(0, 100);\n\n  return updateItem<AnalyticsType>(context, COLLECTIONS.ANALYTICS, analytics._key, {userIds});\n};\n\nexport const getAnalyticsDashboard = async (\n  context: ApiContext,\n  analyticsIdInput: string,\n  rangeDaysInput: number\n): Promise<AnalyticsDashboardType> => {\n  const analyticsId = normalizeText(analyticsIdInput, 36);\n  const rangeDays = Math.floor(Number(rangeDaysInput));\n\n  if(!analyticsId || !VALID_RANGE_DAYS.has(rangeDays)) {\n    throw new UserError(ErrorTypes.INVALID_ARGUMENTS);\n  }\n\n  const analytics = await getAuthorizedAnalytics(context, analyticsId);\n  const endTime = Date.now();\n  const startTime = endTime - rangeDays * 24 * 60 * 60 * 1000 + (rangeDays === 30 ? 60_000 : 0);\n  const client = getRumClient(context);\n  const rawEvents: string[] = [];\n  let nextToken: string | undefined;\n  let page = 0;\n\n  do {\n    const response = await client.send(new GetAppMonitorDataCommand({\n      MaxResults: MAX_RUM_RESULTS,\n      Name: analytics.monitorName,\n      ...(nextToken ? {NextToken: nextToken} : {}),\n      TimeRange: {After: startTime, Before: endTime}\n    }));\n    rawEvents.push(...(response.Events || []));\n    nextToken = response.NextToken;\n    page += 1;\n  } while(nextToken && page < MAX_RUM_PAGES);\n\n  const events = rawEvents\n    .map(normalizeRumEvent)\n    .filter((event): event is NormalizedRumEvent => Boolean(event && event.appId === analytics.appId))\n    .sort((left, right) => right.timestamp - left.timestamp);\n  const sessions = new Set(events.map((event) => event.sessionId).filter(Boolean));\n  const interactionEvents = events.filter((event) => (\n    event.type !== 'page_view' && event.type !== 'view_performance'\n  ));\n  const errorEvents = events.filter((event) => /error|exception|failure/i.test(`${event.type} ${event.name}`));\n  const durations = events.map((event) => event.duration).filter((duration) => duration > 0);\n  const bucketSize = rangeDays === 1 ? 60 * 60 * 1000 : 24 * 60 * 60 * 1000;\n  const buckets = new Map<number, {errors: number; events: number; interactions: number; sessions: Set<string>}>();\n\n  for(let timestamp = Math.floor(startTime / bucketSize) * bucketSize; timestamp <= endTime; timestamp += bucketSize) {\n    buckets.set(timestamp, {errors: 0, events: 0, interactions: 0, sessions: new Set()});\n  }\n\n  events.forEach((event) => {\n    const bucket = buckets.get(Math.floor(event.timestamp / bucketSize) * bucketSize);\n    if(!bucket) {\n      return;\n    }\n    bucket.events += 1;\n    bucket.interactions += event.type === 'page_view' || event.type === 'view_performance' ? 0 : 1;\n    bucket.errors += /error|exception|failure/i.test(`${event.type} ${event.name}`) ? 1 : 0;\n    if(event.sessionId) {\n      bucket.sessions.add(event.sessionId);\n    }\n  });\n\n  return {\n    analyticsId: analytics.analyticsId,\n    appId: analytics.appId,\n    appName: await getAnalyticsAppName(context, analytics),\n    averageDuration: durations.length\n      ? Math.round(durations.reduce((total, duration) => total + duration, 0) / durations.length)\n      : 0,\n    browsers: createBreakdown(events.map((event) => [event.browserName, event.browserVersion].filter(Boolean).join(' ')), events.length),\n    devices: createBreakdown(events.map((event) => event.deviceType), events.length),\n    endTime,\n    errorCount: errorEvents.length,\n    eventCount: events.length,\n    generatedAt: Date.now(),\n    interactions: createBreakdown(interactionEvents.map((event) => event.interaction || event.name), interactionEvents.length),\n    languages: createBreakdown(events.map((event) => event.browserLanguage), events.length),\n    monitorId: analytics.monitorId,\n    monitorName: analytics.monitorName,\n    operatingSystems: createBreakdown(events.map((event) => [event.osName, event.osVersion].filter(Boolean).join(' ')), events.length),\n    pages: createBreakdown(events.map((event) => event.pageId || event.path), events.length),\n    pageViewCount: events.filter((event) => event.type === 'page_view').length,\n    partial: Boolean(nextToken),\n    performanceSamples: durations.length,\n    recentEvents: events.slice(0, 100).map(({appId: _appId, ...event}) => event),\n    sessionCount: sessions.size,\n    startTime,\n    timeline: Array.from(buckets, ([timestamp, bucket]) => ({\n      errors: bucket.errors,\n      events: bucket.events,\n      interactions: bucket.interactions,\n      sessions: bucket.sessions.size,\n      timestamp\n    })),\n    viewPerformance: createViewPerformance(events)\n  };\n};\n"],"names":["CreateAppMonitorCommand","GetAppMonitorCommand","GetAppMonitorDataCommand","RUMClient","createHash","randomUUID","Config","COLLECTIONS","ErrorTypes","UserError","useDb","isAdminUser","addItem","getItemBy","getListBy","updateItem","MAX_APP_ID_LENGTH","MAX_DOMAIN_LENGTH","MAX_MONITOR_NAME_LENGTH","MAX_RUM_PAGES","MAX_RUM_RESULTS","VALID_RANGE_DAYS","Set","collectionInitialization","Map","normalizeText","value","maxLength","String","trim","slice","normalizeDomain","replace","split","toLowerCase","normalizeMonitorName","appId","getDocumentKey","update","digest","requireAdmin","context","session","INVALID_SESSION","requireSession","userId","initializeAnalyticsCollection","databaseName","cacheKey","existingInitialization","get","initialization","database","collection","ANALYTICS","exists","createCollection","error","ensureIndex","fields","type","unique","set","delete","getRumClient","awsConfig","config","aws","accessKeyId","secretAccessKey","sessionToken","credentials","usesRuntimeCredentials","Boolean","process","env","AWS_SESSION_TOKEN","AWS_ACCESS_KEY_ID","AWS_SECRET_ACCESS_KEY","undefined","region","findAwsMonitor","client","monitorName","response","send","Name","monitorId","AppMonitor","Id","domain","Domain","id","name","findOrCreateAwsMonitor","existingMonitor","CustomEvents","Status","CwLogEnabled","Platform","Tags","managedBy","parseMonitorInput","input","appName","INVALID_ARGUMENTS","getAnalyticsByAppId","appIdInput","getAnalyticsConfiguration","analytics","analyticsId","getAnalyticsById","analyticsIdInput","createAnalyticsMonitor","existing","userIds","includes","monitor","_key","regenerateAnalyticsId","hasAccess","parseJsonRecord","Array","isArray","parsed","JSON","parse","getProperty","properties","metadata","aliases","normalizedAliases","map","alias","entries","Object","find","key","has","normalizeRumEvent","rawEvent","source","details","event_details","timestamp","Number","event_timestamp","isFinite","getText","fallback","durationValue","path","event_type","applicationId","browserLanguage","browserName","browserVersion","deviceType","duration","eventId","event_id","interaction","osName","osVersion","outcome","pageId","parentPage","sessionId","user_details","viewId","createBreakdown","values","total","counts","reduce","result","label","from","count","percentage","Math","round","sort","left","right","localeCompare","percentile","percentileValue","length","sorted","toSorted","index","max","ceil","createViewPerformance","events","views","event","samples","push","durations","filter","failureRate","p50","p75","p95","sampleCount","timeoutRate","getAuthorizedAnalytics","getAnalyticsAppName","app","APPS","conditions","field","operator","logic","displayName","getAvailableAnalytics","direction","available","item","enriched","Promise","all","setAnalyticsAccess","userIdsInput","getAnalyticsDashboard","rangeDaysInput","rangeDays","floor","endTime","Date","now","startTime","rawEvents","nextToken","page","MaxResults","NextToken","TimeRange","After","Before","Events","sessions","interactionEvents","errorEvents","test","bucketSize","buckets","errors","interactions","forEach","bucket","add","averageDuration","browsers","join","devices","errorCount","eventCount","generatedAt","languages","operatingSystems","pages","pageViewCount","partial","performanceSamples","recentEvents","_appId","sessionCount","size","timeline","viewPerformance"],"mappings":"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"}