@ucptools/validator 1.0.1 → 1.1.0

package/dist/services/analytics.js

@@ -0,0 +1,862 @@
+"use strict";
+/**
+ * Analytics Service
+ * Business logic for AI Agent Traffic Analytics (V1 + V2)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAgentType = detectAgentType;
+exports.hashIpAddress = hashIpAddress;
+exports.ingestEvents = ingestEvents;
+exports.getAnalyticsSummary = getAnalyticsSummary;
+exports.getTimeseries = getTimeseries;
+exports.getEventLog = getEventLog;
+exports.getFunnelData = getFunnelData;
+exports.getCommerceKPIs = getCommerceKPIs;
+exports.getAgentComparison = getAgentComparison;
+exports.getErrorAnalysis = getErrorAnalysis;
+exports.getCapabilityGaps = getCapabilityGaps;
+exports.createAnalyticsApiKey = createAnalyticsApiKey;
+exports.validateAnalyticsApiKey = validateAnalyticsApiKey;
+exports.getAnalyticsApiKeys = getAnalyticsApiKeys;
+exports.deleteAnalyticsApiKey = deleteAnalyticsApiKey;
+exports.aggregateEventsForDate = aggregateEventsForDate;
+exports.purgeOldEvents = purgeOldEvents;
+exports.getDomainFromApiKey = getDomainFromApiKey;
+exports.userOwnsDomain = userOwnsDomain;
+const drizzle_orm_1 = require("drizzle-orm");
+const index_js_1 = require("../db/index.js");
+const schema_js_1 = require("../db/schema.js");
+const bcryptjs_1 = require("bcryptjs");
+const nanoid_1 = require("nanoid");
+const crypto_1 = require("crypto");
+// Agent detection patterns
+const AGENT_PATTERNS = {
+    gemini: /googlebot|google-extended|gemini/i,
+    chatgpt: /chatgpt|openai|gptbot/i,
+    perplexity: /perplexitybot/i,
+    claude: /anthropic|claude/i,
+    copilot: /copilot|bingbot/i,
+    unknown: /./, // Fallback
+};
+// Funnel stage definitions: maps event types to funnel stages
+const FUNNEL_STAGES = [
+    { stage: 'Discovery', types: ['discovery'] },
+    { stage: 'Browse', types: ['capability', 'capability_negotiation', 'product_browse', 'product_detail'] },
+    { stage: 'Checkout', types: ['checkout', 'checkout_create', 'checkout_update', 'checkout_escalation', 'acp_checkout_create', 'acp_checkout_update'] },
+    { stage: 'Payment', types: ['payment_attempt', 'payment_success', 'acp_payment'] },
+    { stage: 'Order', types: ['order', 'order_created', 'acp_order'] },
+];
+// Checkout-related event types that trigger session tracking
+const CHECKOUT_EVENT_TYPES = new Set([
+    'checkout', 'checkout_create', 'checkout_update', 'checkout_escalation',
+    'payment_attempt', 'payment_success', 'payment_failure',
+    'order', 'order_created',
+    'acp_checkout_create', 'acp_checkout_update', 'acp_payment', 'acp_order',
+]);
+// Error fix suggestions by HTTP status
+const ERROR_SUGGESTIONS = {
+    400: 'Check request payload format — agents may be sending malformed data',
+    401: 'Verify authentication configuration — agents cannot access protected endpoints',
+    403: 'Check CORS and permission settings — agents are being blocked',
+    404: 'Verify endpoint URLs in your UCP profile — agents are hitting missing routes',
+    422: 'Validate your product feed — line items or checkout data may be invalid',
+    429: 'Increase rate limits — AI agents are being throttled',
+    500: 'Check server logs for internal errors on UCP endpoints',
+    502: 'Check upstream service health — your backend may be down',
+    503: 'Service unavailable — check capacity and health checks',
+};
+/**
+ * Detect agent type and version from User-Agent string
+ */
+function detectAgentType(userAgent) {
+    if (!userAgent) {
+        return { type: 'unknown' };
+    }
+    for (const [agentType, pattern] of Object.entries(AGENT_PATTERNS)) {
+        if (agentType === 'unknown')
+            continue;
+        if (pattern.test(userAgent)) {
+            // Try to extract version
+            const versionMatch = userAgent.match(/\/(\d+(?:\.\d+)*)/);
+            return {
+                type: agentType,
+                version: versionMatch?.[1],
+            };
+        }
+    }
+    return { type: 'unknown' };
+}
+/**
+ * Hash an IP address for privacy
+ */
+function hashIpAddress(ip) {
+    return (0, crypto_1.createHash)('sha256').update(ip).digest('hex').substring(0, 64);
+}
+/**
+ * Upsert checkout session tracking
+ */
+async function upsertCheckoutSession(domainId, event) {
+    if (!event.checkoutSessionId)
+        return;
+    const db = (0, index_js_1.getDb)();
+    const detection = detectAgentType(event.userAgent);
+    try {
+        const existing = await db
+            .select()
+            .from(schema_js_1.analyticsCheckoutSessions)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsCheckoutSessions.domainId, domainId), (0, drizzle_orm_1.eq)(schema_js_1.analyticsCheckoutSessions.checkoutSessionId, event.checkoutSessionId)))
+            .limit(1);
+        if (existing.length > 0) {
+            const session = existing[0];
+            const updates = {
+                updatedAt: new Date(),
+            };
+            if (event.checkoutState)
+                updates.currentState = event.checkoutState;
+            if (event.lineItemsCount)
+                updates.lineItemsCount = event.lineItemsCount;
+            if (event.orderTotal)
+                updates.orderTotal = String(event.orderTotal);
+            if (event.currency)
+                updates.currency = event.currency;
+            if (event.paymentHandler)
+                updates.paymentHandler = event.paymentHandler;
+            // Track escalation
+            if (event.checkoutState === 'requires_escalation' || event.eventType === 'checkout_escalation') {
+                updates.hadEscalation = true;
+                if (event.escalationReason)
+                    updates.escalationReason = event.escalationReason;
+            }
+            // Track timing milestones
+            const now = new Date();
+            if (['payment_attempt', 'acp_payment'].includes(event.eventType) && !session.paymentAttemptedAt) {
+                updates.paymentAttemptedAt = now;
+            }
+            if (['order_created', 'order', 'acp_order'].includes(event.eventType) || event.checkoutState === 'completed') {
+                updates.completedAt = now;
+                if (session.checkoutCreatedAt) {
+                    updates.timeToPurchaseMs = now.getTime() - session.checkoutCreatedAt.getTime();
+                }
+            }
+            await db
+                .update(schema_js_1.analyticsCheckoutSessions)
+                .set(updates)
+                .where((0, drizzle_orm_1.eq)(schema_js_1.analyticsCheckoutSessions.id, session.id));
+        }
+        else {
+            await db.insert(schema_js_1.analyticsCheckoutSessions).values({
+                domainId,
+                checkoutSessionId: event.checkoutSessionId,
+                agentType: detection.type,
+                agentProfileUrl: event.agentProfileUrl,
+                protocol: event.protocol || 'unknown',
+                currentState: event.checkoutState || 'incomplete',
+                lineItemsCount: event.lineItemsCount,
+                orderTotal: event.orderTotal ? String(event.orderTotal) : undefined,
+                currency: event.currency,
+                paymentHandler: event.paymentHandler,
+                checkoutCreatedAt: new Date(),
+            });
+        }
+    }
+    catch (error) {
+        // Don't fail event ingestion if session tracking fails
+        console.error('[Analytics] Checkout session upsert error:', error);
+    }
+}
+/**
+ * Ingest analytics events (V1 + V2)
+ */
+async function ingestEvents(domainId, events) {
+    const db = (0, index_js_1.getDb)();
+    const errors = [];
+    let received = 0;
+    for (const event of events) {
+        try {
+            const detection = detectAgentType(event.userAgent);
+            const newEvent = {
+                domainId,
+                eventType: event.eventType,
+                agentType: detection.type,
+                agentVersion: detection.version,
+                userAgent: event.userAgent,
+                endpoint: event.endpoint,
+                capability: event.capability,
+                httpStatus: event.httpStatus,
+                responseTimeMs: event.responseTimeMs,
+                sessionId: event.sessionId,
+                ipHash: event.ipAddress ? hashIpAddress(event.ipAddress) : undefined,
+                countryCode: event.countryCode?.toUpperCase().substring(0, 2),
+                metadata: event.metadata ? JSON.stringify(event.metadata) : undefined,
+                // V2 fields
+                protocol: event.protocol,
+                checkoutSessionId: event.checkoutSessionId,
+                checkoutState: event.checkoutState,
+                lineItemsCount: event.lineItemsCount,
+                orderTotal: event.orderTotal ? String(event.orderTotal) : undefined,
+                currency: event.currency,
+                paymentHandler: event.paymentHandler,
+                escalationReason: event.escalationReason,
+                agentProfileUrl: event.agentProfileUrl,
+            };
+            await db.insert(schema_js_1.analyticsEvents).values(newEvent);
+            received++;
+            // Track checkout sessions for V2 funnel correlation
+            if (event.checkoutSessionId && CHECKOUT_EVENT_TYPES.has(event.eventType)) {
+                await upsertCheckoutSession(domainId, event);
+            }
+        }
+        catch (error) {
+            errors.push(`Failed to insert event: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    return { received, errors: errors.length > 0 ? errors : [] };
+}
+/**
+ * Get analytics summary for a domain
+ */
+async function getAnalyticsSummary(domainId, startDate, endDate) {
+    const db = (0, index_js_1.getDb)();
+    // Get total events and basic stats
+    const statsResult = await db
+        .select({
+        totalEvents: (0, drizzle_orm_1.count)(),
+        avgResponseTimeMs: (0, drizzle_orm_1.sql) `COALESCE(AVG(${schema_js_1.analyticsEvents.responseTimeMs}), 0)`,
+        errorCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsEvents.httpStatus} >= 400)`,
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate)));
+    const stats = statsResult[0];
+    const totalEvents = Number(stats?.totalEvents) || 0;
+    const avgResponseTimeMs = Math.round(Number(stats?.avgResponseTimeMs) || 0);
+    const errorCount = Number(stats?.errorCount) || 0;
+    const errorRate = totalEvents > 0 ? (errorCount / totalEvents) * 100 : 0;
+    // Get unique sessions
+    const sessionsResult = await db
+        .select({
+        count: (0, drizzle_orm_1.sql) `COUNT(DISTINCT ${schema_js_1.analyticsEvents.sessionId})`,
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate), (0, drizzle_orm_1.sql) `${schema_js_1.analyticsEvents.sessionId} IS NOT NULL`));
+    const uniqueSessions = Number(sessionsResult[0]?.count) || 0;
+    // Get unique agent types
+    const agentsResult = await db
+        .select({
+        count: (0, drizzle_orm_1.sql) `COUNT(DISTINCT ${schema_js_1.analyticsEvents.agentType})`,
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate)));
+    const uniqueAgents = Number(agentsResult[0]?.count) || 0;
+    // Events by type
+    const eventsByTypeResult = await db
+        .select({
+        eventType: schema_js_1.analyticsEvents.eventType,
+        count: (0, drizzle_orm_1.count)(),
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate)))
+        .groupBy(schema_js_1.analyticsEvents.eventType);
+    const eventsByType = {};
+    for (const row of eventsByTypeResult) {
+        eventsByType[row.eventType] = Number(row.count);
+    }
+    // Events by agent
+    const eventsByAgentResult = await db
+        .select({
+        agentType: schema_js_1.analyticsEvents.agentType,
+        count: (0, drizzle_orm_1.count)(),
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate)))
+        .groupBy(schema_js_1.analyticsEvents.agentType);
+    const eventsByAgent = {};
+    for (const row of eventsByAgentResult) {
+        eventsByAgent[row.agentType || 'unknown'] = Number(row.count);
+    }
+    // Top capabilities
+    const topCapabilitiesResult = await db
+        .select({
+        capability: schema_js_1.analyticsEvents.capability,
+        count: (0, drizzle_orm_1.count)(),
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate), (0, drizzle_orm_1.sql) `${schema_js_1.analyticsEvents.capability} IS NOT NULL`))
+        .groupBy(schema_js_1.analyticsEvents.capability)
+        .orderBy((0, drizzle_orm_1.desc)((0, drizzle_orm_1.count)()))
+        .limit(10);
+    const topCapabilities = topCapabilitiesResult.map(row => ({
+        capability: row.capability,
+        count: Number(row.count),
+    }));
+    // Top endpoints
+    const topEndpointsResult = await db
+        .select({
+        endpoint: schema_js_1.analyticsEvents.endpoint,
+        count: (0, drizzle_orm_1.count)(),
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate), (0, drizzle_orm_1.sql) `${schema_js_1.analyticsEvents.endpoint} IS NOT NULL`))
+        .groupBy(schema_js_1.analyticsEvents.endpoint)
+        .orderBy((0, drizzle_orm_1.desc)((0, drizzle_orm_1.count)()))
+        .limit(10);
+    const topEndpoints = topEndpointsResult.map(row => ({
+        endpoint: row.endpoint,
+        count: Number(row.count),
+    }));
+    return {
+        totalEvents,
+        uniqueSessions,
+        uniqueAgents,
+        avgResponseTimeMs,
+        errorRate: Math.round(errorRate * 100) / 100,
+        eventsByType,
+        eventsByAgent,
+        topCapabilities,
+        topEndpoints,
+    };
+}
+/**
+ * Get timeseries data for a domain
+ */
+async function getTimeseries(domainId, startDate, endDate, granularity = 'day') {
+    const db = (0, index_js_1.getDb)();
+    // Determine date truncation based on granularity
+    const truncate = granularity === 'hour' ? 'hour' : granularity === 'week' ? 'week' : 'day';
+    const result = await db
+        .select({
+        timestamp: (0, drizzle_orm_1.sql) `date_trunc('${drizzle_orm_1.sql.raw(truncate)}', ${schema_js_1.analyticsEvents.createdAt})::text`,
+        eventCount: (0, drizzle_orm_1.count)(),
+        errorCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsEvents.httpStatus} >= 400)`,
+        avgResponseTimeMs: (0, drizzle_orm_1.sql) `COALESCE(AVG(${schema_js_1.analyticsEvents.responseTimeMs}), 0)`,
+        uniqueSessions: (0, drizzle_orm_1.sql) `COUNT(DISTINCT ${schema_js_1.analyticsEvents.sessionId})`,
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate)))
+        .groupBy((0, drizzle_orm_1.sql) `date_trunc('${drizzle_orm_1.sql.raw(truncate)}', ${schema_js_1.analyticsEvents.createdAt})`)
+        .orderBy((0, drizzle_orm_1.sql) `date_trunc('${drizzle_orm_1.sql.raw(truncate)}', ${schema_js_1.analyticsEvents.createdAt})`);
+    const data = result.map(row => ({
+        timestamp: row.timestamp,
+        eventCount: Number(row.eventCount),
+        uniqueSessions: Number(row.uniqueSessions),
+        errorCount: Number(row.errorCount),
+        avgResponseTimeMs: Math.round(Number(row.avgResponseTimeMs)),
+    }));
+    return {
+        granularity,
+        startDate: startDate.toISOString(),
+        endDate: endDate.toISOString(),
+        data,
+    };
+}
+/**
+ * Get event log with pagination
+ */
+async function getEventLog(domainId, filters, pagination) {
+    const db = (0, index_js_1.getDb)();
+    // Build conditions
+    const conditions = [(0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId)];
+    if (filters.eventType) {
+        conditions.push((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.eventType, filters.eventType));
+    }
+    if (filters.agentType) {
+        conditions.push((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.agentType, filters.agentType));
+    }
+    if (filters.startDate) {
+        conditions.push((0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, filters.startDate));
+    }
+    if (filters.endDate) {
+        conditions.push((0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, filters.endDate));
+    }
+    if (filters.capability) {
+        conditions.push((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.capability, filters.capability));
+    }
+    if (filters.hasError === true) {
+        conditions.push((0, drizzle_orm_1.sql) `${schema_js_1.analyticsEvents.httpStatus} >= 400`);
+    }
+    else if (filters.hasError === false) {
+        conditions.push((0, drizzle_orm_1.sql) `${schema_js_1.analyticsEvents.httpStatus} < 400 OR ${schema_js_1.analyticsEvents.httpStatus} IS NULL`);
+    }
+    const whereClause = (0, drizzle_orm_1.and)(...conditions);
+    // Get total count
+    const countResult = await db
+        .select({ total: (0, drizzle_orm_1.count)() })
+        .from(schema_js_1.analyticsEvents)
+        .where(whereClause);
+    const total = Number(countResult[0]?.total) || 0;
+    // Get events (including V2 fields)
+    const events = await db
+        .select({
+        id: schema_js_1.analyticsEvents.id,
+        eventType: schema_js_1.analyticsEvents.eventType,
+        agentType: schema_js_1.analyticsEvents.agentType,
+        agentVersion: schema_js_1.analyticsEvents.agentVersion,
+        endpoint: schema_js_1.analyticsEvents.endpoint,
+        capability: schema_js_1.analyticsEvents.capability,
+        httpStatus: schema_js_1.analyticsEvents.httpStatus,
+        responseTimeMs: schema_js_1.analyticsEvents.responseTimeMs,
+        countryCode: schema_js_1.analyticsEvents.countryCode,
+        createdAt: schema_js_1.analyticsEvents.createdAt,
+        protocol: schema_js_1.analyticsEvents.protocol,
+        checkoutSessionId: schema_js_1.analyticsEvents.checkoutSessionId,
+        checkoutState: schema_js_1.analyticsEvents.checkoutState,
+        orderTotal: schema_js_1.analyticsEvents.orderTotal,
+        currency: schema_js_1.analyticsEvents.currency,
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where(whereClause)
+        .orderBy((0, drizzle_orm_1.desc)(schema_js_1.analyticsEvents.createdAt))
+        .limit(pagination.limit)
+        .offset(pagination.offset);
+    return {
+        events: events,
+        total,
+        limit: pagination.limit,
+        offset: pagination.offset,
+    };
+}
+// ============================================================================
+// V2: Funnel, Commerce KPIs, Agent Comparison, Error Analysis, Capability Gaps
+// ============================================================================
+/**
+ * Get conversion funnel data
+ */
+async function getFunnelData(domainId, startDate, endDate) {
+    const db = (0, index_js_1.getDb)();
+    const stages = [];
+    for (const funnelStage of FUNNEL_STAGES) {
+        // Build IN clause for event types
+        const typePlaceholders = funnelStage.types.map(t => `'${t}'`).join(',');
+        const result = await db
+            .select({
+            count: (0, drizzle_orm_1.sql) `COUNT(DISTINCT COALESCE(${schema_js_1.analyticsEvents.checkoutSessionId}, ${schema_js_1.analyticsEvents.sessionId}, ${schema_js_1.analyticsEvents.ipHash}))`,
+        })
+            .from(schema_js_1.analyticsEvents)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate), (0, drizzle_orm_1.sql) `${schema_js_1.analyticsEvents.eventType} IN (${drizzle_orm_1.sql.raw(typePlaceholders)})`));
+        stages.push({
+            stage: funnelStage.stage,
+            count: Number(result[0]?.count) || 0,
+            conversionRate: 0,
+            dropOffRate: 0,
+        });
+    }
+    // Calculate conversion rates
+    for (let i = 0; i < stages.length; i++) {
+        if (i === 0) {
+            stages[i].conversionRate = 100;
+            stages[i].dropOffRate = 0;
+        }
+        else {
+            const prevCount = stages[i - 1].count;
+            stages[i].conversionRate = prevCount > 0
+                ? Math.round((stages[i].count / prevCount) * 10000) / 100
+                : 0;
+            stages[i].dropOffRate = prevCount > 0
+                ? Math.round(((prevCount - stages[i].count) / prevCount) * 10000) / 100
+                : 0;
+        }
+    }
+    const overallConversionRate = stages[0].count > 0
+        ? Math.round((stages[stages.length - 1].count / stages[0].count) * 10000) / 100
+        : 0;
+    return {
+        stages,
+        overallConversionRate,
+        timeRange: { startDate: startDate.toISOString(), endDate: endDate.toISOString() },
+    };
+}
+/**
+ * Get commerce KPIs from checkout sessions
+ */
+async function getCommerceKPIs(domainId, startDate, endDate) {
+    const db = (0, index_js_1.getDb)();
+    const orderStats = await db
+        .select({
+        totalRevenue: (0, drizzle_orm_1.sql) `COALESCE(SUM(${schema_js_1.analyticsCheckoutSessions.orderTotal}::numeric), 0)`,
+        orderCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsCheckoutSessions.currentState} = 'completed')`,
+        checkoutCount: (0, drizzle_orm_1.count)(),
+        escalationCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsCheckoutSessions.hadEscalation} = true)`,
+        avgTimeToPurchase: (0, drizzle_orm_1.sql) `AVG(${schema_js_1.analyticsCheckoutSessions.timeToPurchaseMs})`,
+        ucpCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsCheckoutSessions.protocol} = 'ucp')`,
+        acpCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsCheckoutSessions.protocol} = 'acp')`,
+        unknownCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsCheckoutSessions.protocol} NOT IN ('ucp', 'acp'))`,
+    })
+        .from(schema_js_1.analyticsCheckoutSessions)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsCheckoutSessions.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsCheckoutSessions.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsCheckoutSessions.createdAt, endDate)));
+    const stats = orderStats[0];
+    const totalRevenue = Number(stats?.totalRevenue) || 0;
+    const orderCount = Number(stats?.orderCount) || 0;
+    const checkoutCount = Number(stats?.checkoutCount) || 0;
+    const escalationCount = Number(stats?.escalationCount) || 0;
+    // Payment handler distribution
+    const paymentHandlers = await db
+        .select({
+        handler: schema_js_1.analyticsCheckoutSessions.paymentHandler,
+        count: (0, drizzle_orm_1.count)(),
+    })
+        .from(schema_js_1.analyticsCheckoutSessions)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsCheckoutSessions.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsCheckoutSessions.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsCheckoutSessions.createdAt, endDate), (0, drizzle_orm_1.sql) `${schema_js_1.analyticsCheckoutSessions.paymentHandler} IS NOT NULL`))
+        .groupBy(schema_js_1.analyticsCheckoutSessions.paymentHandler);
+    const paymentHandlerDistribution = {};
+    for (const row of paymentHandlers) {
+        paymentHandlerDistribution[row.handler || 'unknown'] = Number(row.count);
+    }
+    return {
+        agenticRevenue: totalRevenue,
+        agenticConversionRate: checkoutCount > 0
+            ? Math.round((orderCount / checkoutCount) * 10000) / 100
+            : 0,
+        averageOrderValue: orderCount > 0
+            ? Math.round((totalRevenue / orderCount) * 100) / 100
+            : 0,
+        escalationRate: checkoutCount > 0
+            ? Math.round((escalationCount / checkoutCount) * 10000) / 100
+            : 0,
+        checkoutAbandonmentRate: checkoutCount > 0
+            ? Math.round(((checkoutCount - orderCount) / checkoutCount) * 10000) / 100
+            : 0,
+        timeToPurchaseMs: Math.round(Number(stats?.avgTimeToPurchase) || 0),
+        protocolDistribution: {
+            ucp: Number(stats?.ucpCount) || 0,
+            acp: Number(stats?.acpCount) || 0,
+            unknown: Number(stats?.unknownCount) || 0,
+        },
+        paymentHandlerDistribution,
+    };
+}
+/**
+ * Get agent comparison data
+ */
+async function getAgentComparison(domainId, startDate, endDate) {
+    const db = (0, index_js_1.getDb)();
+    // Per-agent event counts by type
+    const agentStats = await db
+        .select({
+        agentType: schema_js_1.analyticsEvents.agentType,
+        totalEvents: (0, drizzle_orm_1.count)(),
+        discoveries: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsEvents.eventType} = 'discovery')`,
+        checkouts: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsEvents.eventType} IN ('checkout', 'checkout_create', 'acp_checkout_create'))`,
+        orders: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsEvents.eventType} IN ('order', 'order_created', 'acp_order'))`,
+        errorCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsEvents.httpStatus} >= 400)`,
+        avgResponseTimeMs: (0, drizzle_orm_1.sql) `AVG(${schema_js_1.analyticsEvents.responseTimeMs})`,
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate)))
+        .groupBy(schema_js_1.analyticsEvents.agentType);
+    // Per-agent revenue from checkout sessions
+    const agentRevenue = await db
+        .select({
+        agentType: schema_js_1.analyticsCheckoutSessions.agentType,
+        totalRevenue: (0, drizzle_orm_1.sql) `COALESCE(SUM(${schema_js_1.analyticsCheckoutSessions.orderTotal}::numeric), 0)`,
+        orderCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsCheckoutSessions.currentState} = 'completed')`,
+    })
+        .from(schema_js_1.analyticsCheckoutSessions)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsCheckoutSessions.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsCheckoutSessions.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsCheckoutSessions.createdAt, endDate)))
+        .groupBy(schema_js_1.analyticsCheckoutSessions.agentType);
+    const revenueMap = new Map(agentRevenue.map(r => [r.agentType, r]));
+    const agents = agentStats.map(stat => {
+        const totalEvents = Number(stat.totalEvents);
+        const orders = Number(stat.orders);
+        const checkouts = Number(stat.checkouts);
+        const rev = revenueMap.get(stat.agentType);
+        const revenue = Number(rev?.totalRevenue) || 0;
+        const revOrderCount = Number(rev?.orderCount) || 0;
+        return {
+            agentType: stat.agentType || 'unknown',
+            totalEvents,
+            discoveries: Number(stat.discoveries),
+            checkouts,
+            orders,
+            conversionRate: checkouts > 0
+                ? Math.round((orders / checkouts) * 10000) / 100
+                : 0,
+            avgOrderValue: revOrderCount > 0
+                ? Math.round((revenue / revOrderCount) * 100) / 100
+                : 0,
+            errorRate: totalEvents > 0
+                ? Math.round((Number(stat.errorCount) / totalEvents) * 10000) / 100
+                : 0,
+            avgResponseTimeMs: Math.round(Number(stat.avgResponseTimeMs) || 0),
+        };
+    });
+    return { agents: agents.sort((a, b) => b.totalEvents - a.totalEvents) };
+}
+/**
+ * Get error analysis data
+ */
+async function getErrorAnalysis(domainId, startDate, endDate) {
+    const db = (0, index_js_1.getDb)();
+    // Total events and errors
+    const totalResult = await db
+        .select({
+        totalErrors: (0, drizzle_orm_1.count)(),
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate), (0, drizzle_orm_1.sql) `${schema_js_1.analyticsEvents.httpStatus} >= 400`));
+    const totalAllResult = await db
+        .select({
+        total: (0, drizzle_orm_1.count)(),
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate)));
+    const totalErrors = Number(totalResult[0]?.totalErrors) || 0;
+    const totalAll = Number(totalAllResult[0]?.total) || 0;
+    // Group errors by HTTP status
+    const errorGroups = await db
+        .select({
+        httpStatus: schema_js_1.analyticsEvents.httpStatus,
+        count: (0, drizzle_orm_1.count)(),
+        endpoints: (0, drizzle_orm_1.sql) `array_agg(DISTINCT ${schema_js_1.analyticsEvents.endpoint})`,
+        agents: (0, drizzle_orm_1.sql) `array_agg(DISTINCT ${schema_js_1.analyticsEvents.agentType})`,
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate), (0, drizzle_orm_1.sql) `${schema_js_1.analyticsEvents.httpStatus} >= 400`))
+        .groupBy(schema_js_1.analyticsEvents.httpStatus)
+        .orderBy((0, drizzle_orm_1.desc)((0, drizzle_orm_1.count)()))
+        .limit(20);
+    const errors = errorGroups.map(group => {
+        const statusCode = group.httpStatus || 0;
+        const groupCount = Number(group.count);
+        // Filter out null values from arrays
+        const endpoints = Array.isArray(group.endpoints)
+            ? group.endpoints.filter(Boolean)
+            : [];
+        const agents = Array.isArray(group.agents)
+            ? group.agents.filter(Boolean)
+            : [];
+        return {
+            errorCode: String(statusCode),
+            count: groupCount,
+            percentage: totalErrors > 0
+                ? Math.round((groupCount / totalErrors) * 10000) / 100
+                : 0,
+            suggestion: ERROR_SUGGESTIONS[statusCode] || 'Review server logs for this error type',
+            affectedEndpoints: endpoints,
+            affectedAgents: agents,
+        };
+    });
+    return {
+        totalErrors,
+        errorRate: totalAll > 0
+            ? Math.round((totalErrors / totalAll) * 10000) / 100
+            : 0,
+        errors,
+    };
+}
+/**
+ * Get capability gap analysis
+ */
+async function getCapabilityGaps(domainId, startDate, endDate) {
+    const db = (0, index_js_1.getDb)();
+    const capStats = await db
+        .select({
+        capability: schema_js_1.analyticsEvents.capability,
+        totalRequests: (0, drizzle_orm_1.count)(),
+        errorCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsEvents.httpStatus} >= 400)`,
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsEvents.domainId, domainId), (0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startDate), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endDate), (0, drizzle_orm_1.sql) `${schema_js_1.analyticsEvents.capability} IS NOT NULL`))
+        .groupBy(schema_js_1.analyticsEvents.capability)
+        .orderBy((0, drizzle_orm_1.desc)((0, drizzle_orm_1.count)()));
+    const gaps = capStats.map(stat => {
+        const total = Number(stat.totalRequests);
+        const errors = Number(stat.errorCount);
+        const errorRate = total > 0 ? errors / total : 0;
+        return {
+            requestedCapability: stat.capability,
+            requestCount: total,
+            supported: errorRate < 0.5,
+            suggestedAction: errorRate >= 0.5
+                ? `Agents requested "${stat.capability}" ${total} times but got ${Math.round(errorRate * 100)}% errors. Consider adding this capability.`
+                : `"${stat.capability}" is working well with ${Math.round((1 - errorRate) * 100)}% success rate.`,
+        };
+    });
+    const totalRequests = gaps.reduce((sum, g) => sum + g.requestCount, 0);
+    const supportedRequests = gaps
+        .filter(g => g.supported)
+        .reduce((sum, g) => sum + g.requestCount, 0);
+    return {
+        gaps,
+        matchRate: totalRequests > 0
+            ? Math.round((supportedRequests / totalRequests) * 10000) / 100
+            : 100,
+    };
+}
+// ============================================================================
+// API Key Management (unchanged from V1)
+// ============================================================================
+/**
+ * Create an analytics API key for a domain
+ */
+async function createAnalyticsApiKey(domainId, name) {
+    const db = (0, index_js_1.getDb)();
+    // Generate key: ucpa_<random>
+    const key = `ucpa_${(0, nanoid_1.nanoid)(32)}`;
+    const keyHash = await (0, bcryptjs_1.hash)(key, 10);
+    const keyPrefix = key.substring(0, 12);
+    const [apiKey] = await db
+        .insert(schema_js_1.analyticsApiKeys)
+        .values({
+        domainId,
+        keyHash,
+        keyPrefix,
+        name,
+    })
+        .returning();
+    return {
+        key,
+        apiKey: {
+            id: apiKey.id,
+            name: apiKey.name,
+            keyPrefix: apiKey.keyPrefix,
+            lastUsedAt: apiKey.lastUsedAt,
+            isActive: apiKey.isActive ?? true,
+            createdAt: apiKey.createdAt,
+        },
+    };
+}
+/**
+ * Validate an analytics API key
+ */
+async function validateAnalyticsApiKey(key) {
+    const db = (0, index_js_1.getDb)();
+    // Extract prefix
+    const keyPrefix = key.substring(0, 12);
+    // Find keys with matching prefix
+    const keys = await db
+        .select()
+        .from(schema_js_1.analyticsApiKeys)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsApiKeys.keyPrefix, keyPrefix), (0, drizzle_orm_1.eq)(schema_js_1.analyticsApiKeys.isActive, true)));
+    for (const apiKey of keys) {
+        const valid = await (0, bcryptjs_1.compare)(key, apiKey.keyHash);
+        if (valid) {
+            // Update last used
+            await db
+                .update(schema_js_1.analyticsApiKeys)
+                .set({ lastUsedAt: new Date() })
+                .where((0, drizzle_orm_1.eq)(schema_js_1.analyticsApiKeys.id, apiKey.id));
+            return { valid: true, domainId: apiKey.domainId, keyId: apiKey.id };
+        }
+    }
+    return { valid: false };
+}
+/**
+ * Get analytics API keys for a domain
+ */
+async function getAnalyticsApiKeys(domainId) {
+    const db = (0, index_js_1.getDb)();
+    const keys = await db
+        .select({
+        id: schema_js_1.analyticsApiKeys.id,
+        name: schema_js_1.analyticsApiKeys.name,
+        keyPrefix: schema_js_1.analyticsApiKeys.keyPrefix,
+        lastUsedAt: schema_js_1.analyticsApiKeys.lastUsedAt,
+        isActive: schema_js_1.analyticsApiKeys.isActive,
+        createdAt: schema_js_1.analyticsApiKeys.createdAt,
+    })
+        .from(schema_js_1.analyticsApiKeys)
+        .where((0, drizzle_orm_1.eq)(schema_js_1.analyticsApiKeys.domainId, domainId))
+        .orderBy((0, drizzle_orm_1.desc)(schema_js_1.analyticsApiKeys.createdAt));
+    return keys.map(k => ({
+        ...k,
+        isActive: k.isActive ?? true,
+    }));
+}
+/**
+ * Delete an analytics API key
+ */
+async function deleteAnalyticsApiKey(keyId, domainId) {
+    const db = (0, index_js_1.getDb)();
+    await db
+        .delete(schema_js_1.analyticsApiKeys)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsApiKeys.id, keyId), (0, drizzle_orm_1.eq)(schema_js_1.analyticsApiKeys.domainId, domainId)));
+    return true;
+}
+/**
+ * Aggregate events for a specific date (for cron job)
+ */
+async function aggregateEventsForDate(date) {
+    const db = (0, index_js_1.getDb)();
+    // Get start and end of day
+    const startOfDay = new Date(date);
+    startOfDay.setHours(0, 0, 0, 0);
+    const endOfDay = new Date(date);
+    endOfDay.setHours(23, 59, 59, 999);
+    // Get aggregated data grouped by domain, event type, and agent type
+    const aggregates = await db
+        .select({
+        domainId: schema_js_1.analyticsEvents.domainId,
+        eventType: schema_js_1.analyticsEvents.eventType,
+        agentType: (0, drizzle_orm_1.sql) `COALESCE(${schema_js_1.analyticsEvents.agentType}, 'unknown')`,
+        eventCount: (0, drizzle_orm_1.count)(),
+        uniqueSessions: (0, drizzle_orm_1.sql) `COUNT(DISTINCT ${schema_js_1.analyticsEvents.sessionId})`,
+        avgResponseTimeMs: (0, drizzle_orm_1.sql) `AVG(${schema_js_1.analyticsEvents.responseTimeMs})`,
+        errorCount: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${schema_js_1.analyticsEvents.httpStatus} >= 400)`,
+    })
+        .from(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.gte)(schema_js_1.analyticsEvents.createdAt, startOfDay), (0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, endOfDay)))
+        .groupBy(schema_js_1.analyticsEvents.domainId, schema_js_1.analyticsEvents.eventType, (0, drizzle_orm_1.sql) `COALESCE(${schema_js_1.analyticsEvents.agentType}, 'unknown')`);
+    // Insert or update aggregates
+    for (const agg of aggregates) {
+        const existing = await db
+            .select()
+            .from(schema_js_1.analyticsAggregates)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.analyticsAggregates.domainId, agg.domainId), (0, drizzle_orm_1.eq)(schema_js_1.analyticsAggregates.date, startOfDay), (0, drizzle_orm_1.eq)(schema_js_1.analyticsAggregates.eventType, agg.eventType), (0, drizzle_orm_1.eq)(schema_js_1.analyticsAggregates.agentType, agg.agentType)))
+            .limit(1);
+        if (existing.length > 0) {
+            await db
+                .update(schema_js_1.analyticsAggregates)
+                .set({
+                eventCount: Number(agg.eventCount),
+                uniqueSessions: Number(agg.uniqueSessions),
+                avgResponseTimeMs: agg.avgResponseTimeMs ? Math.round(Number(agg.avgResponseTimeMs)) : null,
+                errorCount: Number(agg.errorCount),
+                updatedAt: new Date(),
+            })
+                .where((0, drizzle_orm_1.eq)(schema_js_1.analyticsAggregates.id, existing[0].id));
+        }
+        else {
+            await db.insert(schema_js_1.analyticsAggregates).values({
+                domainId: agg.domainId,
+                date: startOfDay,
+                eventType: agg.eventType,
+                agentType: agg.agentType,
+                eventCount: Number(agg.eventCount),
+                uniqueSessions: Number(agg.uniqueSessions),
+                avgResponseTimeMs: agg.avgResponseTimeMs ? Math.round(Number(agg.avgResponseTimeMs)) : null,
+                errorCount: Number(agg.errorCount),
+            });
+        }
+    }
+}
+/**
+ * Purge old events (for data retention)
+ */
+async function purgeOldEvents(retentionDays) {
+    const db = (0, index_js_1.getDb)();
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
+    await db
+        .delete(schema_js_1.analyticsEvents)
+        .where((0, drizzle_orm_1.lte)(schema_js_1.analyticsEvents.createdAt, cutoffDate));
+    return 0;
+}
+/**
+ * Get domain ID from analytics API key (for route validation)
+ */
+async function getDomainFromApiKey(key) {
+    const result = await validateAnalyticsApiKey(key);
+    return result.valid ? result.domainId || null : null;
+}
+/**
+ * Check if user owns a domain (for dashboard access)
+ */
+async function userOwnsDomain(userId, domainId) {
+    const db = (0, index_js_1.getDb)();
+    const result = await db
+        .select()
+        .from(schema_js_1.monitoredDomains)
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.monitoredDomains.id, domainId), (0, drizzle_orm_1.eq)(schema_js_1.monitoredDomains.userId, userId), (0, drizzle_orm_1.eq)(schema_js_1.monitoredDomains.isActive, true)))
+        .limit(1);
+    return result.length > 0;
+}
+//# sourceMappingURL=analytics.js.map