@stacksjs/ts-analytics 0.1.6

package/src/handlers/alerts.ts

@@ -0,0 +1,328 @@
+/**
+ * Alerts and Email Reports handlers
+ */
+
+import { generateId } from '../index'
+import { dynamodb, TABLE_NAME, unmarshall, marshall } from '../lib/dynamodb'
+import { jsonResponse, errorResponse } from '../utils/response'
+import { getQueryParams } from '../../deploy/lambda-adapter'
+import { sendEmail } from '../lib/email'
+
+/**
+ * POST /api/sites/{siteId}/alerts
+ */
+export async function handleCreateAlert(request: Request, siteId: string): Promise<Response> {
+  try {
+    const body = await request.json() as Record<string, any>
+
+    if (!body.name || !body.metric || !body.condition || body.threshold === undefined) {
+      return jsonResponse({ error: 'Missing required fields: name, metric, condition, threshold' }, 400)
+    }
+
+    const validConditions = ['above', 'below', 'equals', 'change_percent']
+    if (!validConditions.includes(body.condition)) {
+      return jsonResponse({ error: `Invalid condition. Must be one of: ${validConditions.join(', ')}` }, 400)
+    }
+
+    const alertId = generateId()
+    const alert = {
+      pk: `SITE#${siteId}`,
+      sk: `ALERT#${alertId}`,
+      id: alertId,
+      siteId,
+      name: body.name,
+      metric: body.metric,
+      condition: body.condition,
+      threshold: body.threshold,
+      email: body.email,
+      webhookUrl: body.webhookUrl,
+      isActive: body.isActive ?? true,
+      lastTriggered: null,
+      createdAt: new Date().toISOString(),
+    }
+
+    await dynamodb.putItem({
+      TableName: TABLE_NAME,
+      Item: marshall(alert),
+    })
+
+    return jsonResponse({ alert }, 201)
+  }
+catch (error) {
+    console.error('Create alert error:', error)
+    return errorResponse('Failed to create alert')
+  }
+}
+
+/**
+ * GET /api/sites/{siteId}/alerts
+ */
+export async function handleGetAlerts(_request: Request, siteId: string): Promise<Response> {
+  try {
+    const result = await dynamodb.query({
+      TableName: TABLE_NAME,
+      KeyConditionExpression: 'pk = :pk AND begins_with(sk, :prefix)',
+      ExpressionAttributeValues: {
+        ':pk': { S: `SITE#${siteId}` },
+        ':prefix': { S: 'ALERT#' },
+      },
+    }) as { Items?: any[] }
+
+    const alerts = (result.Items || []).map(unmarshall)
+
+    return jsonResponse({ alerts })
+  }
+catch (error) {
+    console.error('Get alerts error:', error)
+    return errorResponse('Failed to fetch alerts')
+  }
+}
+
+/**
+ * DELETE /api/sites/{siteId}/alerts/{alertId}
+ */
+export async function handleDeleteAlert(_request: Request, siteId: string, alertId: string): Promise<Response> {
+  try {
+    await dynamodb.deleteItem({
+      TableName: TABLE_NAME,
+      Key: marshall({
+        pk: `SITE#${siteId}`,
+        sk: `ALERT#${alertId}`,
+      }),
+    })
+
+    return jsonResponse({ success: true })
+  }
+catch (error) {
+    console.error('Delete alert error:', error)
+    return errorResponse('Failed to delete alert')
+  }
+}
+
+/**
+ * POST /api/sites/{siteId}/email-reports
+ */
+export async function handleCreateEmailReport(request: Request, siteId: string): Promise<Response> {
+  try {
+    const body = await request.json() as Record<string, any>
+
+    if (!body.email || !body.schedule) {
+      return jsonResponse({ error: 'Missing required fields: email, schedule' }, 400)
+    }
+
+    const validSchedules = ['daily', 'weekly', 'monthly']
+    if (!validSchedules.includes(body.schedule)) {
+      return jsonResponse({ error: `Invalid schedule. Must be one of: ${validSchedules.join(', ')}` }, 400)
+    }
+
+    const reportId = generateId()
+    const report = {
+      pk: `SITE#${siteId}`,
+      sk: `EMAIL_REPORT#${reportId}`,
+      id: reportId,
+      siteId,
+      email: body.email,
+      schedule: body.schedule,
+      metrics: body.metrics || ['visitors', 'pageviews', 'bounceRate', 'avgDuration'],
+      isActive: body.isActive ?? true,
+      lastSent: null,
+      createdAt: new Date().toISOString(),
+    }
+
+    await dynamodb.putItem({
+      TableName: TABLE_NAME,
+      Item: marshall(report),
+    })
+
+    return jsonResponse({ report }, 201)
+  }
+catch (error) {
+    console.error('Create email report error:', error)
+    return errorResponse('Failed to create email report')
+  }
+}
+
+/**
+ * GET /api/sites/{siteId}/email-reports
+ */
+export async function handleGetEmailReports(_request: Request, siteId: string): Promise<Response> {
+  try {
+    const result = await dynamodb.query({
+      TableName: TABLE_NAME,
+      KeyConditionExpression: 'pk = :pk AND begins_with(sk, :prefix)',
+      ExpressionAttributeValues: {
+        ':pk': { S: `SITE#${siteId}` },
+        ':prefix': { S: 'EMAIL_REPORT#' },
+      },
+    }) as { Items?: any[] }
+
+    const reports = (result.Items || []).map(unmarshall)
+
+    return jsonResponse({ reports })
+  }
+catch (error) {
+    console.error('Get email reports error:', error)
+    return errorResponse('Failed to fetch email reports')
+  }
+}
+
+/**
+ * DELETE /api/sites/{siteId}/email-reports/{reportId}
+ */
+export async function handleDeleteEmailReport(_request: Request, siteId: string, reportId: string): Promise<Response> {
+  try {
+    await dynamodb.deleteItem({
+      TableName: TABLE_NAME,
+      Key: marshall({
+        pk: `SITE#${siteId}`,
+        sk: `EMAIL_REPORT#${reportId}`,
+      }),
+    })
+
+    return jsonResponse({ success: true })
+  }
+catch (error) {
+    console.error('Delete email report error:', error)
+    return errorResponse('Failed to delete email report')
+  }
+}
+
+// ── Scheduled email digests (#93) ──────────────────────────────────────────
+const DIGEST_PERIOD_MS: Record<string, number> = {
+  daily: 24 * 60 * 60 * 1000,
+  weekly: 7 * 24 * 60 * 60 * 1000,
+  monthly: 30 * 24 * 60 * 60 * 1000,
+}
+
+/** Pure: whether a digest on `schedule` is due given its last send. */
+export function digestDue(schedule: string, lastSentMs: number | null, now: number): boolean {
+  const period = DIGEST_PERIOD_MS[schedule] ?? DIGEST_PERIOD_MS.weekly
+  return lastSentMs === null || now - lastSentMs >= period
+}
+
+/**
+ * Build the digest body from the report's CONFIGURED metrics (#139) — the
+ * old digest ignored them and sent a single pageview count regardless.
+ */
+export async function buildDigestText(siteId: string, siteName: string, startIso: string, endIso: string, metrics: string[], label: string): Promise<string> {
+  const { queryAllItems, querySessionItemsInRange } = await import('../lib/dynamodb')
+  const [pvRes, sessRes] = await Promise.all([
+    queryAllItems({
+      TableName: TABLE_NAME,
+      KeyConditionExpression: 'pk = :pk AND sk BETWEEN :s AND :e',
+      ExpressionAttributeValues: { ':pk': { S: `SITE#${siteId}` }, ':s': { S: `PAGEVIEW#${startIso}` }, ':e': { S: `PAGEVIEW#${endIso}~` } },
+    }),
+    querySessionItemsInRange(siteId, new Date(startIso), new Date(endIso)),
+  ])
+  const pageviews = (pvRes.Items || []).map(unmarshall)
+  const sessions = (sessRes.Items || []).map(unmarshall)
+
+  const wants = (m: string): boolean => metrics.length === 0 || metrics.includes(m)
+  const lines: string[] = [`Analytics summary for ${siteName} — last ${label}`, '']
+
+  // Daily-unique sums (the same semantics the dashboard reports).
+  const dailyVisitors = new Map<string, Set<string>>()
+  for (const pv of pageviews) {
+    const day = String(pv.timestamp).slice(0, 10)
+    let set = dailyVisitors.get(day)
+    if (!set) {
+      set = new Set()
+      dailyVisitors.set(day, set)
+    }
+    if (pv.visitorId)
+      set.add(pv.visitorId)
+  }
+  const visitors = [...dailyVisitors.values()].reduce((sum, set) => sum + set.size, 0)
+  if (wants('visitors'))
+    lines.push(`Visitors: ${visitors}`)
+  if (wants('pageviews'))
+    lines.push(`Pageviews: ${pageviews.length}`)
+  if (wants('sessions'))
+    lines.push(`Sessions: ${sessions.length}`)
+  if (wants('bounceRate')) {
+    const bounces = sessions.filter(x => x.isBounce).length
+    lines.push(`Bounce rate: ${sessions.length > 0 ? Math.round((bounces / sessions.length) * 100) : 0}%`)
+  }
+  if (wants('avgDuration')) {
+    const totalMs = sessions.reduce((sum, x) => sum + (x.activeTime > 0 ? x.activeTime : (x.duration || 0)), 0)
+    const avgS = sessions.length > 0 ? Math.round(totalMs / sessions.length / 1000) : 0
+    lines.push(`Avg time on site: ${Math.floor(avgS / 60)}:${String(avgS % 60).padStart(2, '0')}`)
+  }
+
+  if (wants('topPages') || metrics.length === 0) {
+    const byPath = new Map<string, number>()
+    for (const pv of pageviews) byPath.set(pv.path || '/', (byPath.get(pv.path || '/') || 0) + 1)
+    const top = [...byPath.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5)
+    if (top.length > 0) {
+      lines.push('', 'Top pages:')
+      for (const [path, count] of top) lines.push(`  ${path} — ${count} views`)
+    }
+  }
+  if (wants('topReferrers') || metrics.length === 0) {
+    const bySource = new Map<string, number>()
+    for (const sess of sessions) {
+      const source = sess.referrerSource || 'Direct'
+      bySource.set(source, (bySource.get(source) || 0) + 1)
+    }
+    const top = [...bySource.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5)
+    if (top.length > 0) {
+      lines.push('', 'Top sources:')
+      for (const [source, count] of top) lines.push(`  ${source} — ${count} sessions`)
+    }
+  }
+  return lines.join('\n')
+}
+
+/** Send every due email-report digest across all sites (scheduled job, #93/#90). */
+export async function sendDueEmailDigests(): Promise<number> {
+  const sites = await dynamodb.query({
+    TableName: TABLE_NAME,
+    KeyConditionExpression: 'pk = :pk',
+    ExpressionAttributeValues: { ':pk': { S: 'SITES' } },
+  }) as { Items?: any[] }
+
+  const now = Date.now()
+  const nowIso = new Date(now).toISOString()
+  let sent = 0
+
+  for (const raw of (sites.Items || [])) {
+    const site = unmarshall(raw)
+    const siteId = site.siteId || site.id
+    if (!siteId)
+      continue
+    const reports = await dynamodb.query({
+      TableName: TABLE_NAME,
+      KeyConditionExpression: 'pk = :pk AND begins_with(sk, :p)',
+      ExpressionAttributeValues: { ':pk': { S: `SITE#${siteId}` }, ':p': { S: 'EMAIL_REPORT#' } },
+    }) as { Items?: any[] }
+
+    for (const rraw of (reports.Items || [])) {
+      const report = unmarshall(rraw)
+      if (report.isActive === false)
+        continue
+      const lastSentMs = report.lastSent ? new Date(report.lastSent).getTime() : null
+      if (!digestDue(report.schedule, lastSentMs, now))
+        continue
+
+      const period = DIGEST_PERIOD_MS[report.schedule] ?? DIGEST_PERIOD_MS.weekly
+      const sinceIso = new Date(now - period).toISOString()
+      const label = report.schedule === 'daily' ? 'day' : report.schedule === 'monthly' ? 'month' : 'week'
+      const metrics = Array.isArray(report.metrics) ? report.metrics : []
+      const text = await buildDigestText(siteId, site.name || siteId, sinceIso, nowIso, metrics, label)
+
+      await sendEmail({
+        to: report.email,
+        subject: `Your ${report.schedule} analytics report — ${site.name || siteId}`,
+        text,
+      })
+      await dynamodb.updateItem({
+        TableName: TABLE_NAME,
+        Key: { pk: { S: `SITE#${siteId}` }, sk: { S: report.sk } },
+        UpdateExpression: 'SET lastSent = :now',
+        ExpressionAttributeValues: { ':now': { S: nowIso } },
+      })
+      sent++
+    }
+  }
+  return sent
+}

package/src/handlers/annotations.ts

@@ -0,0 +1,128 @@
+/**
+ * Annotation handlers
+ */
+
+import { generateId } from '../index'
+import { dynamodb, TABLE_NAME, unmarshall, marshall } from '../lib/dynamodb'
+import { parseDateRange } from '../utils/date'
+import { jsonResponse, errorResponse } from '../utils/response'
+import { getQueryParams } from '../../deploy/lambda-adapter'
+
+/**
+ * POST /api/sites/{siteId}/annotations
+ */
+export async function handleCreateAnnotation(request: Request, siteId: string): Promise<Response> {
+  try {
+    const body = await request.json() as Record<string, any>
+
+    if (!body.text) {
+      return jsonResponse({ error: 'Missing required field: text' }, 400)
+    }
+
+    const annotationId = generateId()
+    const timestamp = body.timestamp || new Date().toISOString()
+    const annotation = {
+      pk: `SITE#${siteId}`,
+      sk: `ANNOTATION#${timestamp}#${annotationId}`,
+      id: annotationId,
+      siteId,
+      text: body.text,
+      type: body.type || 'general',
+      timestamp,
+      createdAt: new Date().toISOString(),
+      createdBy: body.createdBy || 'system',
+    }
+
+    await dynamodb.putItem({
+      TableName: TABLE_NAME,
+      Item: marshall(annotation),
+    })
+
+    return jsonResponse({ annotation }, 201)
+  }
+catch (error) {
+    console.error('Create annotation error:', error)
+    return errorResponse('Failed to create annotation')
+  }
+}
+
+/**
+ * GET /api/sites/{siteId}/annotations
+ */
+export async function handleGetAnnotations(request: Request, siteId: string): Promise<Response> {
+  try {
+    const query = getQueryParams(request)
+    const { startDate, endDate } = parseDateRange(query)
+
+    const result = await dynamodb.query({
+      TableName: TABLE_NAME,
+      KeyConditionExpression: 'pk = :pk AND sk BETWEEN :start AND :end',
+      ExpressionAttributeValues: {
+        ':pk': { S: `SITE#${siteId}` },
+        ':start': { S: `ANNOTATION#${startDate.toISOString()}` },
+        ':end': { S: `ANNOTATION#${endDate.toISOString()}Z` },
+      },
+    }) as { Items?: any[] }
+
+    const annotations = (result.Items || []).map(unmarshall)
+      .sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime())
+
+    return jsonResponse({ annotations })
+  }
+catch (error) {
+    console.error('Get annotations error:', error)
+    return errorResponse('Failed to fetch annotations')
+  }
+}
+
+/**
+ * DELETE /api/sites/{siteId}/annotations/{annotationId}
+ */
+export async function handleDeleteAnnotation(request: Request, siteId: string, annotationId: string): Promise<Response> {
+  try {
+    const query = getQueryParams(request)
+    const timestamp = query.timestamp
+
+    if (!timestamp) {
+      // Need to find the annotation first
+      const result = await dynamodb.query({
+        TableName: TABLE_NAME,
+        KeyConditionExpression: 'pk = :pk AND begins_with(sk, :prefix)',
+        ExpressionAttributeValues: {
+          ':pk': { S: `SITE#${siteId}` },
+          ':prefix': { S: 'ANNOTATION#' },
+        },
+      }) as { Items?: any[] }
+
+      const annotations = (result.Items || []).map(unmarshall)
+      const annotation = annotations.find(a => a.id === annotationId)
+
+      if (!annotation) {
+        return jsonResponse({ error: 'Annotation not found' }, 404)
+      }
+
+      await dynamodb.deleteItem({
+        TableName: TABLE_NAME,
+        Key: marshall({
+          pk: `SITE#${siteId}`,
+          sk: annotation.sk,
+        }),
+      })
+    }
+else {
+      await dynamodb.deleteItem({
+        TableName: TABLE_NAME,
+        Key: marshall({
+          pk: `SITE#${siteId}`,
+          sk: `ANNOTATION#${timestamp}#${annotationId}`,
+        }),
+      })
+    }
+
+    return jsonResponse({ success: true })
+  }
+catch (error) {
+    console.error('Delete annotation error:', error)
+    return errorResponse('Failed to delete annotation')
+  }
+}

package/src/handlers/api-keys.ts

@@ -0,0 +1,240 @@
+/**
+ * API Key handlers
+ */
+
+import { generateId } from '../index'
+import { randomToken } from '../lib/crypto-random'
+import { dynamodb, TABLE_NAME, unmarshall, marshall } from '../lib/dynamodb'
+import { rateLimitAllow } from '../lib/rate-limit'
+import { jsonResponse, errorResponse } from '../utils/response'
+import { getClientIP, getQueryParams } from '../../deploy/lambda-adapter'
+
+/** Max key-validation cache MISSES per minute per IP — throttles brute-forcing
+ * of unknown keys without affecting legit clients (their valid key is cached). */
+const KEY_VALIDATION_LIMIT_PER_MIN = 60
+
+/**
+ * Generate a secure API key
+ */
+export function generateApiKey(): string {
+  // CSPRNG so keys aren't guessable/enumerable (#130).
+  return `ak_${randomToken(32)}`
+}
+
+/**
+ * Token validation result
+ */
+export interface ApiKeyValidationResult {
+  valid: boolean
+  siteId?: string
+  keyId?: string
+}
+
+// In-memory cache for validated tokens (5-minute TTL)
+const tokenCache = new Map<string, { result: ApiKeyValidationResult; expires: number }>()
+
+/**
+ * Validate an API key from request headers.
+ * Checks X-Analytics-Token or Authorization: Bearer header.
+ * Requires the key to be active and have the specified permission.
+ */
+export async function handleValidateApiKey(
+  request: Request,
+  requiredPermission: string = 'read',
+): Promise<ApiKeyValidationResult> {
+  const token = request.headers.get('X-Analytics-Token')
+    || request.headers.get('Authorization')?.replace('Bearer ', '')
+
+  if (!token || !token.startsWith('ak_')) {
+    return { valid: false }
+  }
+
+  // Check cache
+  const cached = tokenCache.get(`${token}:${requiredPermission}`)
+  if (cached && cached.expires > Date.now()) {
+    return cached.result
+  }
+
+  // Only cache MISSES reach here. Brute-force tries many distinct keys (all
+  // misses), so rate-limiting misses per IP throttles enumeration while legit
+  // clients (reusing one valid, cached key) are unaffected (#158).
+  if (!rateLimitAllow(`keyauth:${getClientIP(request)}`, KEY_VALIDATION_LIMIT_PER_MIN, 60_000)) {
+    return { valid: false }
+  }
+
+  try {
+    // Query GSI1 to look up key by value
+    const queryResult = await dynamodb.query({
+      TableName: TABLE_NAME,
+      IndexName: 'GSI1',
+      KeyConditionExpression: 'gsi1pk = :pk',
+      ExpressionAttributeValues: {
+        ':pk': { S: `API_KEY#${token}` },
+      },
+    }) as { Items?: any[] }
+
+    if (!queryResult.Items || queryResult.Items.length === 0) {
+      const invalid = { valid: false } as const
+      tokenCache.set(`${token}:${requiredPermission}`, { result: invalid, expires: Date.now() + 60_000 })
+      return invalid
+    }
+
+    const keyRecord = unmarshall(queryResult.Items[0])
+
+    if (!keyRecord.isActive) {
+      return { valid: false }
+    }
+
+    const permissions: string[] = keyRecord.permissions || []
+    if (!permissions.includes(requiredPermission)) {
+      return { valid: false }
+    }
+
+    const result: ApiKeyValidationResult = {
+      valid: true,
+      siteId: keyRecord.siteId,
+      keyId: keyRecord.id,
+    }
+
+    // Cache for 5 minutes
+    tokenCache.set(`${token}:${requiredPermission}`, { result, expires: Date.now() + 5 * 60 * 1000 })
+
+    // Fire-and-forget: update lastUsed and usageCount
+    dynamodb.updateItem({
+      TableName: TABLE_NAME,
+      Key: {
+        pk: { S: `SITE#${keyRecord.siteId}` },
+        sk: { S: `API_KEY#${keyRecord.id}` },
+      },
+      UpdateExpression: 'SET lastUsed = :now, usageCount = if_not_exists(usageCount, :zero) + :one',
+      ExpressionAttributeValues: {
+        ':now': { S: new Date().toISOString() },
+        ':zero': { N: '0' },
+        ':one': { N: '1' },
+      },
+    }).catch((e: unknown) => console.error('Failed to update API key usage:', e))
+
+    return result
+  }
+catch (error) {
+    console.error('Validate API key error:', error)
+    return { valid: false }
+  }
+}
+
+
+
+
+
+/**
+ * GET /api/sites/{siteId}/api-keys
+ * Returns the single API key for the site
+ */
+export async function handleGetApiKey(_request: Request, siteId: string): Promise<Response> {
+  try {
+    const result = await dynamodb.query({
+      TableName: TABLE_NAME,
+      KeyConditionExpression: 'pk = :pk AND begins_with(sk, :prefix)',
+      ExpressionAttributeValues: {
+        ':pk': { S: `SITE#${siteId}` },
+        ':prefix': { S: 'API_KEY#' },
+      },
+    }) as { Items?: any[] }
+
+    const keys = (result.Items || []).map(unmarshall)
+    const active = keys.find(k => k.isActive) || keys[0]
+
+    if (!active) {
+      return jsonResponse({ apiKey: null })
+    }
+
+    return jsonResponse({
+      apiKey: {
+        id: active.id,
+        key: active.key,
+        name: active.name,
+        permissions: active.permissions,
+        createdAt: active.createdAt,
+        lastUsed: active.lastUsed,
+        usageCount: active.usageCount,
+      },
+    })
+  }
+catch (error) {
+    console.error('Get API key error:', error)
+    return errorResponse('Failed to fetch API key')
+  }
+}
+
+/**
+ * POST /api/sites/{siteId}/api-keys/regenerate
+ * Deletes all existing keys and creates a fresh one
+ */
+export async function handleRegenerateApiKey(_request: Request, siteId: string): Promise<Response> {
+  try {
+    // 1. Query existing keys
+    const result = await dynamodb.query({
+      TableName: TABLE_NAME,
+      KeyConditionExpression: 'pk = :pk AND begins_with(sk, :prefix)',
+      ExpressionAttributeValues: {
+        ':pk': { S: `SITE#${siteId}` },
+        ':prefix': { S: 'API_KEY#' },
+      },
+    }) as { Items?: any[] }
+
+    // 2. Delete each existing key
+    for (const item of result.Items || []) {
+      const record = unmarshall(item)
+      // Invalidate cache entries for old key
+      tokenCache.delete(`${record.key}:read`)
+      tokenCache.delete(`${record.key}:error-tracking`)
+      await dynamodb.deleteItem({
+        TableName: TABLE_NAME,
+        Key: marshall({
+          pk: `SITE#${siteId}`,
+          sk: `API_KEY#${record.id}`,
+        }),
+      })
+    }
+
+    // 3. Create new key
+    const keyId = generateId()
+    const apiKey = generateApiKey()
+    const permissions = ['read']
+
+    await dynamodb.putItem({
+      TableName: TABLE_NAME,
+      Item: marshall({
+        pk: `SITE#${siteId}`,
+        sk: `API_KEY#${keyId}`,
+        gsi1pk: `API_KEY#${apiKey}`,
+        gsi1sk: `SITE#${siteId}`,
+        id: keyId,
+        siteId,
+        name: 'Default',
+        key: apiKey,
+        keyPrefix: apiKey.slice(0, 8),
+        permissions,
+        lastUsed: null,
+        usageCount: 0,
+        isActive: true,
+        createdAt: new Date().toISOString(),
+      }),
+    })
+
+    // 4. Return the new key
+    return jsonResponse({
+      apiKey: {
+        id: keyId,
+        key: apiKey,
+        name: 'Default',
+        permissions,
+        createdAt: new Date().toISOString(),
+      },
+    })
+  }
+catch (error) {
+    console.error('Regenerate API key error:', error)
+    return errorResponse('Failed to regenerate API key')
+  }
+}