Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

new public api (#791)

Bill Yang561cd52bad95
diff --git a/client/src/api/admin/endpoints/sites.ts b/client/src/api/admin/endpoints/sites.ts
index da64a29fc..5e7bf6276 100644
--- a/client/src/api/admin/endpoints/sites.ts
+++ b/client/src/api/admin/endpoints/sites.ts
@@ -75,12 +75,11 @@ export function addSite(
blockBots?: boolean;
}
) {
- return authedFetch<{ siteId: number }>("/sites", undefined, {
+ return authedFetch<{ siteId: number }>(`/sites/${organizationId}`, undefined, {
method: "POST",
data: {
domain,
name,
- organizationId,
public: settings?.isPublic || false,
saltUserIds: settings?.saltUserIds || false,
blockBots: settings?.blockBots === undefined ? true : settings?.blockBots,
diff --git a/client/src/app/[site]/api-playground/utils/endpointConfig.ts b/client/src/app/[site]/api-playground/utils/endpointConfig.ts
index c7520283e..d6236e440 100644
--- a/client/src/app/[site]/api-playground/utils/endpointConfig.ts
+++ b/client/src/app/[site]/api-playground/utils/endpointConfig.ts
@@ -358,6 +358,85 @@ export const endpointCategories: EndpointCategory[] = [
},
],
},
+ {
+ name: "Sites",
+ endpoints: [
+ {
+ method: "POST",
+ path: "/sites/:orgId",
+ name: "Create Site",
+ description: "Creates a new site in an organization. Requires admin/owner role.",
+ hasCommonParams: false,
+ pathParams: ["orgId"],
+ hasRequestBody: true,
+ requestBodyExample: {
+ domain: "example.com",
+ name: "My Website",
+ public: false,
+ blockBots: true,
+ },
+ },
+ {
+ method: "GET",
+ path: "/sites/:site",
+ name: "Get Site",
+ description: "Returns details for a specific site",
+ hasCommonParams: false,
+ },
+ {
+ method: "DELETE",
+ path: "/sites/:site",
+ name: "Delete Site",
+ description: "Permanently deletes a site and all its data. Requires admin/owner role.",
+ hasCommonParams: false,
+ },
+ {
+ method: "PUT",
+ path: "/sites/:site/config",
+ name: "Update Site Config",
+ description: "Updates site configuration settings. Requires admin/owner role.",
+ hasCommonParams: false,
+ hasRequestBody: true,
+ requestBodyExample: {
+ public: true,
+ blockBots: true,
+ excludedCountries: ["CN", "RU"],
+ },
+ },
+ {
+ method: "GET",
+ path: "/sites/:site/excluded-ips",
+ name: "Get Excluded IPs",
+ description: "Returns the list of excluded IP addresses",
+ hasCommonParams: false,
+ },
+ {
+ method: "GET",
+ path: "/sites/:site/excluded-countries",
+ name: "Get Excluded Countries",
+ description: "Returns the list of excluded country codes",
+ hasCommonParams: false,
+ },
+ {
+ method: "GET",
+ path: "/sites/:site/private-link-config",
+ name: "Get Private Link Config",
+ description: "Returns the private link key configuration",
+ hasCommonParams: false,
+ },
+ {
+ method: "POST",
+ path: "/sites/:site/private-link-config",
+ name: "Update Private Link",
+ description: "Generates or revokes a private link key. Requires admin/owner role.",
+ hasCommonParams: false,
+ hasRequestBody: true,
+ requestBodyExample: {
+ action: "generate_private_link_key",
+ },
+ },
+ ],
+ },
];
// Flatten all endpoints for easy lookup
@@ -441,11 +520,19 @@ export const parameterMetadata: Record<
time_zone: { label: "Time Zone", type: "text", placeholder: "America/New_York" },
identified_only: { label: "Identified Only", type: "select", options: ["true", "false"] },
// Path params
+ orgId: { label: "Organization ID", type: "text", placeholder: "org_abc123" },
goalId: { label: "Goal ID", type: "number", placeholder: "Goal ID" },
funnelId: { label: "Funnel ID", type: "number", placeholder: "Funnel ID" },
sessionId: { label: "Session ID", type: "text", placeholder: "Session ID" },
userId: { label: "User ID", type: "text", placeholder: "User ID" },
stepNumber: { label: "Step Number", type: "number", placeholder: "Step number (1-indexed)" },
+ siteId: { label: "Site ID", type: "number", placeholder: "Site ID" },
+ // Sites-specific params
+ action: {
+ label: "Action",
+ type: "select",
+ options: ["generate_private_link_key", "revoke_private_link_key"],
+ },
};
// Method colors for UI
diff --git a/client/src/app/admin/components/organizations/OrganizationsTable.tsx b/client/src/app/admin/components/organizations/OrganizationsTable.tsx
index 9103ce46f..7fdb5fc2d 100644
--- a/client/src/app/admin/components/organizations/OrganizationsTable.tsx
+++ b/client/src/app/admin/components/organizations/OrganizationsTable.tsx
@@ -1,6 +1,6 @@
"use client";
-import { useState, useMemo, useCallback } from "react";
+import { useState, useMemo, useCallback, Fragment } from "react";
import { AdminOrganizationData } from "@/api/admin/endpoints";
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
import { Badge } from "@/components/ui/badge";
@@ -229,8 +229,8 @@ export function OrganizationsTable({ organizations, isLoading, searchQuery }: Or
))
) : paginatedOrganizations && paginatedOrganizations.length > 0 ? (
paginatedOrganizations.map(row => (
- <>
- <TableRow key={row.id} className="group">
+ <Fragment key={row.id}>
+ <TableRow className="group">
{row.getVisibleCells().map(cell => (
<TableCell key={cell.id}>{flexRender(cell.column.columnDef.cell, cell.getContext())}</TableCell>
))}
@@ -242,7 +242,7 @@ export function OrganizationsTable({ organizations, isLoading, searchQuery }: Or
</TableCell>
</TableRow>
)}
- </>
+ </Fragment>
))
) : (
<TableRow>
diff --git a/docs/content/docs/api/meta.json b/docs/content/docs/api/meta.json
index f62b74823..dd6f8da30 100644
--- a/docs/content/docs/api/meta.json
+++ b/docs/content/docs/api/meta.json
@@ -1,4 +1,4 @@
{
"title": "API",
- "pages": ["getting-started", "sending-events", "stats"]
+ "pages": ["getting-started", "sending-events", "stats", "sites"]
}
diff --git a/docs/content/docs/api/sites.mdx b/docs/content/docs/api/sites.mdx
new file mode 100644
index 000000000..bb2b27d58
--- /dev/null
+++ b/docs/content/docs/api/sites.mdx
@@ -0,0 +1,1753 @@
+---
+title: Sites
+description: Manage sites, configuration, private links, and exclusion settings
+full: true
+---
+
+import { TypeTable } from 'fumadocs-ui/components/type-table';
+import { Tab, Tabs } from 'fumadocs-ui/components/tabs';
+
+See the [API Reference](/docs/api/getting-started) for authentication details.
+
+## Endpoints
+
+<div className="flex flex-col gap-2 my-6">
+ <a href="#create-site" className="flex items-center gap-3 p-3 rounded-lg bg-fd-secondary/50 hover:bg-fd-secondary transition-colors no-underline">
+ <span className="px-2 py-1 text-xs font-bold rounded bg-blue-500/20 text-blue-600 dark:text-blue-400">POST</span>
+ <code className="text-sm">/api/sites/:orgId</code>
+ </a>
+ <a href="#get-site" className="flex items-center gap-3 p-3 rounded-lg bg-fd-secondary/50 hover:bg-fd-secondary transition-colors no-underline">
+ <span className="px-2 py-1 text-xs font-bold rounded bg-green-500/20 text-green-600 dark:text-green-400">GET</span>
+ <code className="text-sm">/api/sites/:siteId</code>
+ </a>
+ <a href="#delete-site" className="flex items-center gap-3 p-3 rounded-lg bg-fd-secondary/50 hover:bg-fd-secondary transition-colors no-underline">
+ <span className="px-2 py-1 text-xs font-bold rounded bg-red-500/20 text-red-600 dark:text-red-400">DELETE</span>
+ <code className="text-sm">/api/sites/:siteId</code>
+ </a>
+ <a href="#update-site-config" className="flex items-center gap-3 p-3 rounded-lg bg-fd-secondary/50 hover:bg-fd-secondary transition-colors no-underline">
+ <span className="px-2 py-1 text-xs font-bold rounded bg-yellow-500/20 text-yellow-600 dark:text-yellow-400">PUT</span>
+ <code className="text-sm">/api/sites/:siteId/config</code>
+ </a>
+ <a href="#get-excluded-ips" className="flex items-center gap-3 p-3 rounded-lg bg-fd-secondary/50 hover:bg-fd-secondary transition-colors no-underline">
+ <span className="px-2 py-1 text-xs font-bold rounded bg-green-500/20 text-green-600 dark:text-green-400">GET</span>
+ <code className="text-sm">/api/sites/:siteId/excluded-ips</code>
+ </a>
+ <a href="#get-excluded-countries" className="flex items-center gap-3 p-3 rounded-lg bg-fd-secondary/50 hover:bg-fd-secondary transition-colors no-underline">
+ <span className="px-2 py-1 text-xs font-bold rounded bg-green-500/20 text-green-600 dark:text-green-400">GET</span>
+ <code className="text-sm">/api/sites/:siteId/excluded-countries</code>
+ </a>
+ <a href="#get-private-link-config" className="flex items-center gap-3 p-3 rounded-lg bg-fd-secondary/50 hover:bg-fd-secondary transition-colors no-underline">
+ <span className="px-2 py-1 text-xs font-bold rounded bg-green-500/20 text-green-600 dark:text-green-400">GET</span>
+ <code className="text-sm">/api/sites/:siteId/private-link-config</code>
+ </a>
+ <a href="#update-private-link-config" className="flex items-center gap-3 p-3 rounded-lg bg-fd-secondary/50 hover:bg-fd-secondary transition-colors no-underline">
+ <span className="px-2 py-1 text-xs font-bold rounded bg-blue-500/20 text-blue-600 dark:text-blue-400">POST</span>
+ <code className="text-sm">/api/sites/:siteId/private-link-config</code>
+ </a>
+</div>
+
+---
+
+## Create Site
+
+<div className="grid grid-cols-1 xl:grid-cols-2 gap-8">
+<div>
+
+```
+POST /api/sites/:orgId
+```
+
+Creates a new site within an organization. Requires admin or owner role in the organization.
+
+### Path Parameters
+
+<TypeTable
+ type={{
+ orgId: {
+ description: 'Organization ID to add the site to',
+ type: 'string',
+ required: true,
+ },
+ }}
+/>
+
+### Request Body
+
+<TypeTable
+ type={{
+ domain: {
+ description: 'Site domain',
+ type: 'string',
+ typeDescription: 'Valid domain format (e.g., example.com)',
+ required: true,
+ },
+ name: {
+ description: 'Site display name',
+ type: 'string',
+ required: true,
+ },
+ public: {
+ description: 'Make analytics publicly accessible',
+ type: 'boolean',
+ default: false,
+ },
+ saltUserIds: {
+ description: 'Salt user IDs for privacy',
+ type: 'boolean',
+ default: false,
+ },
+ blockBots: {
+ description: 'Block bot traffic',
+ type: 'boolean',
+ default: true,
+ },
+ }}
+/>
+
+### Response
+
+Returns the created site object with the assigned `siteId`.
+
+<TypeTable
+ type={{
+ siteId: {
+ description: 'Numeric site ID (auto-assigned)',
+ type: 'number',
+ },
+ id: {
+ description: 'Site UUID',
+ type: 'string',
+ },
+ domain: {
+ description: 'Site domain',
+ type: 'string',
+ },
+ name: {
+ description: 'Site name',
+ type: 'string',
+ },
+ organizationId: {
+ description: 'Organization ID',
+ type: 'string',
+ },
+ createdBy: {
+ description: 'User ID who created the site',
+ type: 'string',
+ },
+ public: {
+ description: 'Whether analytics are public',
+ type: 'boolean',
+ },
+ saltUserIds: {
+ description: 'Whether user IDs are salted',
+ type: 'boolean',
+ },
+ blockBots: {
+ description: 'Whether bot traffic is blocked',
+ type: 'boolean',
+ },
+ }}
+/>
+
+</div>
+<div className="flex flex-col gap-4">
+
+<Tabs items={['cURL', 'JavaScript', 'Python', 'PHP', 'Ruby', 'Go', 'Rust', 'Java', '.NET']}>
+ <Tab value="cURL">
+```bash title="Request"
+curl -X POST "https://api.rybbit.io/api/sites/org_123" \
+ -H "Authorization: Bearer your_api_key_here" \
+ -H "Content-Type: application/json" \
+ -d '{"domain": "example.com", "name": "My Website", "blockBots": true}'
+```
+ </Tab>
+ <Tab value="JavaScript">
+```javascript title="Request"
+const orgId = 'org_123';
+const response = await fetch(
+ `https://api.rybbit.io/api/sites/${orgId}`,
+ {
+ method: 'POST',
+ headers: {
+ 'Authorization': 'Bearer your_api_key_here',
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({
+ domain: 'example.com',
+ name: 'My Website',
+ blockBots: true
+ })
+ }
+);
+
+const data = await response.json();
+```
+ </Tab>
+ <Tab value="Python">
+```python title="Request"
+import requests
+
+org_id = 'org_123'
+response = requests.post(
+ f'https://api.rybbit.io/api/sites/{org_id}',
+ json={
+ 'domain': 'example.com',
+ 'name': 'My Website',
+ 'blockBots': True
+ },
+ headers={
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+)
+
+data = response.json()
+```
+ </Tab>
+ <Tab value="PHP">
+```php title="Request"
+$orgId = 'org_123';
+$ch = curl_init();
+curl_setopt($ch, CURLOPT_URL, "https://api.rybbit.io/api/sites/{$orgId}");
+curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+curl_setopt($ch, CURLOPT_POST, true);
+curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
+ 'domain' => 'example.com',
+ 'name' => 'My Website',
+ 'blockBots' => true
+]));
+curl_setopt($ch, CURLOPT_HTTPHEADER, [
+ 'Authorization: Bearer your_api_key_here',
+ 'Content-Type: application/json'
+]);
+
+$response = curl_exec($ch);
+curl_close($ch);
+
+$data = json_decode($response, true);
+```
+ </Tab>
+ <Tab value="Ruby">
+```ruby title="Request"
+require 'net/http'
+require 'json'
+
+org_id = 'org_123'
+uri = URI("https://api.rybbit.io/api/sites/#{org_id}")
+req = Net::HTTP::Post.new(uri)
+req['Authorization'] = 'Bearer your_api_key_here'
+req['Content-Type'] = 'application/json'
+req.body = {
+ domain: 'example.com',
+ name: 'My Website',
+ blockBots: true
+}.to_json
+
+res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+data = JSON.parse(res.body)
+```
+ </Tab>
+ <Tab value="Go">
+```go title="Request"
+orgId := "org_123"
+body := bytes.NewBuffer([]byte(`{
+ "domain": "example.com",
+ "name": "My Website",
+ "blockBots": true
+}`))
+req, _ := http.NewRequest("POST", "https://api.rybbit.io/api/sites/"+orgId, body)
+req.Header.Set("Authorization", "Bearer your_api_key_here")
+req.Header.Set("Content-Type", "application/json")
+
+client := &http.Client{}
+resp, _ := client.Do(req)
+defer resp.Body.Close()
+
+var data map[string]interface{}
+json.NewDecoder(resp.Body).Decode(&data)
+```
+ </Tab>
+ <Tab value="Rust">
+```rust title="Request"
+let org_id = "org_123";
+let client = reqwest::Client::new();
+let res = client
+ .post(format!("https://api.rybbit.io/api/sites/{}", org_id))
+ .header("Authorization", "Bearer your_api_key_here")
+ .json(&serde_json::json!({
+ "domain": "example.com",
+ "name": "My Website",
+ "blockBots": true
+ }))
+ .send()
+ .await?;
+
+let data: serde_json::Value = res.json().await?;
+```
+ </Tab>
+ <Tab value="Java">
+```java title="Request"
+String orgId = "org_123";
+HttpClient client = HttpClient.newHttpClient();
+String json = "{\"domain\": \"example.com\", \"name\": \"My Website\", \"blockBots\": true}";
+HttpRequest request = HttpRequest.newBuilder()
+ .uri(URI.create("https://api.rybbit.io/api/sites/" + orgId))
+ .header("Authorization", "Bearer your_api_key_here")
+ .header("Content-Type", "application/json")
+ .POST(HttpRequest.BodyPublishers.ofString(json))
+ .build();
+
+HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+```
+ </Tab>
+ <Tab value=".NET">
+```csharp title="Request"
+var orgId = "org_123";
+using var client = new HttpClient();
+client.DefaultRequestHeaders.Add("Authorization", "Bearer your_api_key_here");
+
+var content = new StringContent(
+ "{\"domain\": \"example.com\", \"name\": \"My Website\", \"blockBots\": true}",
+ Encoding.UTF8,
+ "application/json"
+);
+
+var response = await client.PostAsync($"https://api.rybbit.io/api/sites/{orgId}", content);
+var data = await response.Content.ReadAsStringAsync();
+```
+ </Tab>
+</Tabs>
+
+```json title="Response"
+{
+ "siteId": 456,
+ "id": "a1b2c3d4e5f6",
+ "domain": "example.com",
+ "name": "My Website",
+ "organizationId": "org_123",
+ "createdBy": "user_xyz789",
+ "public": false,
+ "saltUserIds": false,
+ "blockBots": true
+}
+```
+
+</div>
+</div>
+
+---
+
+## Get Site
+
+<div className="grid grid-cols-1 xl:grid-cols-2 gap-8">
+<div>
+
+```
+GET /api/sites/:siteId
+```
+
+Returns detailed information about a specific site including its configuration.
+
+### Path Parameters
+
+<TypeTable
+ type={{
+ siteId: {
+ description: 'Site ID',
+ type: 'string | number',
+ required: true,
+ },
+ }}
+/>
+
+### Response
+
+<TypeTable
+ type={{
+ id: {
+ description: 'Site UUID',
+ type: 'string | null',
+ },
+ siteId: {
+ description: 'Numeric site ID',
+ type: 'number',
+ },
+ name: {
+ description: 'Site name',
+ type: 'string',
+ },
+ domain: {
+ description: 'Site domain',
+ type: 'string',
+ },
+ createdAt: {
+ description: 'Creation timestamp',
+ type: 'string',
+ typeDescription: 'ISO 8601 datetime',
+ },
+ updatedAt: {
+ description: 'Last update timestamp',
+ type: 'string',
+ typeDescription: 'ISO 8601 datetime',
+ },
+ createdBy: {
+ description: 'User ID who created the site',
+ type: 'string',
+ },
+ organizationId: {
+ description: 'Organization ID',
+ type: 'string | null',
+ },
+ public: {
+ description: 'Whether the site analytics are publicly accessible',
+ type: 'boolean',
+ },
+ saltUserIds: {
+ description: 'Whether user IDs are salted for privacy',
+ type: 'boolean',
+ },
+ blockBots: {
+ description: 'Whether bot traffic is blocked',
+ type: 'boolean',
+ },
+ isOwner: {
+ description: 'Whether the current user owns this site',
+ type: 'boolean',
+ },
+ sessionReplay: {
+ description: 'Whether session replay is enabled',
+ type: 'boolean',
+ },
+ webVitals: {
+ description: 'Whether Web Vitals tracking is enabled',
+ type: 'boolean',
+ },
+ trackErrors: {
+ description: 'Whether error tracking is enabled',
+ type: 'boolean',
+ },
+ trackOutbound: {
+ description: 'Whether outbound link tracking is enabled',
+ type: 'boolean',
+ },
+ trackUrlParams: {
+ description: 'Whether URL parameter tracking is enabled',
+ type: 'boolean',
+ },
+ }}
+/>
+
+</div>
+<div className="flex flex-col gap-4">
+
+<Tabs items={['cURL', 'JavaScript', 'Python', 'PHP', 'Ruby', 'Go', 'Rust', 'Java', '.NET']}>
+ <Tab value="cURL">
+```bash title="Request"
+curl -X GET "https://api.rybbit.io/api/sites/123" \
+ -H "Authorization: Bearer your_api_key_here"
+```
+ </Tab>
+ <Tab value="JavaScript">
+```javascript title="Request"
+const response = await fetch(
+ 'https://api.rybbit.io/api/sites/123',
+ {
+ headers: {
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+ }
+);
+
+const data = await response.json();
+```
+ </Tab>
+ <Tab value="Python">
+```python title="Request"
+import requests
+
+response = requests.get(
+ 'https://api.rybbit.io/api/sites/123',
+ headers={
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+)
+
+data = response.json()
+```
+ </Tab>
+ <Tab value="PHP">
+```php title="Request"
+$ch = curl_init();
+curl_setopt($ch, CURLOPT_URL, 'https://api.rybbit.io/api/sites/123');
+curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+curl_setopt($ch, CURLOPT_HTTPHEADER, [
+ 'Authorization: Bearer your_api_key_here'
+]);
+
+$response = curl_exec($ch);
+curl_close($ch);
+
+$data = json_decode($response, true);
+```
+ </Tab>
+ <Tab value="Ruby">
+```ruby title="Request"
+require 'net/http'
+require 'json'
+
+uri = URI('https://api.rybbit.io/api/sites/123')
+req = Net::HTTP::Get.new(uri)
+req['Authorization'] = 'Bearer your_api_key_here'
+
+res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+data = JSON.parse(res.body)
+```
+ </Tab>
+ <Tab value="Go">
+```go title="Request"
+req, _ := http.NewRequest("GET", "https://api.rybbit.io/api/sites/123", nil)
+req.Header.Set("Authorization", "Bearer your_api_key_here")
+
+client := &http.Client{}
+resp, _ := client.Do(req)
+defer resp.Body.Close()
+
+var data map[string]interface{}
+json.NewDecoder(resp.Body).Decode(&data)
+```
+ </Tab>
+ <Tab value="Rust">
+```rust title="Request"
+let client = reqwest::Client::new();
+let res = client
+ .get("https://api.rybbit.io/api/sites/123")
+ .header("Authorization", "Bearer your_api_key_here")
+ .send()
+ .await?;
+
+let data: serde_json::Value = res.json().await?;
+```
+ </Tab>
+ <Tab value="Java">
+```java title="Request"
+HttpClient client = HttpClient.newHttpClient();
+HttpRequest request = HttpRequest.newBuilder()
+ .uri(URI.create("https://api.rybbit.io/api/sites/123"))
+ .header("Authorization", "Bearer your_api_key_here")
+ .GET()
+ .build();
+
+HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+```
+ </Tab>
+ <Tab value=".NET">
+```csharp title="Request"
+using var client = new HttpClient();
+client.DefaultRequestHeaders.Add("Authorization", "Bearer your_api_key_here");
+
+var response = await client.GetAsync("https://api.rybbit.io/api/sites/123");
+var data = await response.Content.ReadAsStringAsync();
+```
+ </Tab>
+</Tabs>
+
+```json title="Response"
+{
+ "id": "site_abc123",
+ "siteId": 123,
+ "name": "My Website",
+ "domain": "example.com",
+ "createdAt": "2024-01-15T10:30:00.000Z",
+ "updatedAt": "2024-01-31T14:00:00.000Z",
+ "createdBy": "user_xyz789",
+ "organizationId": "org_def456",
+ "public": false,
+ "saltUserIds": false,
+ "blockBots": true,
+ "isOwner": true,
+ "sessionReplay": true,
+ "webVitals": true,
+ "trackErrors": true,
+ "trackOutbound": true,
+ "trackUrlParams": false
+}
+```
+
+</div>
+</div>
+
+---
+
+## Delete Site
+
+<div className="grid grid-cols-1 xl:grid-cols-2 gap-8">
+<div>
+
+```
+DELETE /api/sites/:siteId
+```
+
+Permanently deletes a site and all its associated data. This action cannot be undone. Requires admin or owner role.
+
+### Path Parameters
+
+<TypeTable
+ type={{
+ siteId: {
+ description: 'Site ID',
+ type: 'string | number',
+ required: true,
+ },
+ }}
+/>
+
+### Response
+
+<TypeTable
+ type={{
+ success: {
+ description: 'Whether the deletion was successful',
+ type: 'boolean',
+ },
+ }}
+/>
+
+</div>
+<div className="flex flex-col gap-4">
+
+<Tabs items={['cURL', 'JavaScript', 'Python', 'PHP', 'Ruby', 'Go', 'Rust', 'Java', '.NET']}>
+ <Tab value="cURL">
+```bash title="Request"
+curl -X DELETE "https://api.rybbit.io/api/sites/123" \
+ -H "Authorization: Bearer your_api_key_here"
+```
+ </Tab>
+ <Tab value="JavaScript">
+```javascript title="Request"
+const response = await fetch(
+ 'https://api.rybbit.io/api/sites/123',
+ {
+ method: 'DELETE',
+ headers: {
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+ }
+);
+
+const data = await response.json();
+```
+ </Tab>
+ <Tab value="Python">
+```python title="Request"
+import requests
+
+response = requests.delete(
+ 'https://api.rybbit.io/api/sites/123',
+ headers={
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+)
+
+data = response.json()
+```
+ </Tab>
+ <Tab value="PHP">
+```php title="Request"
+$ch = curl_init();
+curl_setopt($ch, CURLOPT_URL, 'https://api.rybbit.io/api/sites/123');
+curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
+curl_setopt($ch, CURLOPT_HTTPHEADER, [
+ 'Authorization: Bearer your_api_key_here'
+]);
+
+$response = curl_exec($ch);
+curl_close($ch);
+
+$data = json_decode($response, true);
+```
+ </Tab>
+ <Tab value="Ruby">
+```ruby title="Request"
+require 'net/http'
+require 'json'
+
+uri = URI('https://api.rybbit.io/api/sites/123')
+req = Net::HTTP::Delete.new(uri)
+req['Authorization'] = 'Bearer your_api_key_here'
+
+res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+data = JSON.parse(res.body)
+```
+ </Tab>
+ <Tab value="Go">
+```go title="Request"
+req, _ := http.NewRequest("DELETE", "https://api.rybbit.io/api/sites/123", nil)
+req.Header.Set("Authorization", "Bearer your_api_key_here")
+
+client := &http.Client{}
+resp, _ := client.Do(req)
+defer resp.Body.Close()
+
+var data map[string]interface{}
+json.NewDecoder(resp.Body).Decode(&data)
+```
+ </Tab>
+ <Tab value="Rust">
+```rust title="Request"
+let client = reqwest::Client::new();
+let res = client
+ .delete("https://api.rybbit.io/api/sites/123")
+ .header("Authorization", "Bearer your_api_key_here")
+ .send()
+ .await?;
+
+let data: serde_json::Value = res.json().await?;
+```
+ </Tab>
+ <Tab value="Java">
+```java title="Request"
+HttpClient client = HttpClient.newHttpClient();
+HttpRequest request = HttpRequest.newBuilder()
+ .uri(URI.create("https://api.rybbit.io/api/sites/123"))
+ .header("Authorization", "Bearer your_api_key_here")
+ .DELETE()
+ .build();
+
+HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+```
+ </Tab>
+ <Tab value=".NET">
+```csharp title="Request"
+using var client = new HttpClient();
+client.DefaultRequestHeaders.Add("Authorization", "Bearer your_api_key_here");
+
+var response = await client.DeleteAsync("https://api.rybbit.io/api/sites/123");
+var data = await response.Content.ReadAsStringAsync();
+```
+ </Tab>
+</Tabs>
+
+```json title="Response"
+{
+ "success": true
+}
+```
+
+</div>
+</div>
+
+---
+
+## Update Site Config
+
+<div className="grid grid-cols-1 xl:grid-cols-2 gap-8">
+<div>
+
+```
+PUT /api/sites/:siteId/config
+```
+
+Updates site configuration settings. All fields are optional - only include the fields you want to update. Requires admin or owner role.
+
+### Path Parameters
+
+<TypeTable
+ type={{
+ siteId: {
+ description: 'Site ID',
+ type: 'string | number',
+ required: true,
+ },
+ }}
+/>
+
+### Request Body
+
+<TypeTable
+ type={{
+ domain: {
+ description: 'Site domain',
+ type: 'string',
+ typeDescription: 'Valid domain format (e.g., example.com)',
+ required: false,
+ },
+ public: {
+ description: 'Make analytics publicly accessible',
+ type: 'boolean',
+ required: false,
+ },
+ saltUserIds: {
+ description: 'Salt user IDs for privacy',
+ type: 'boolean',
+ required: false,
+ },
+ blockBots: {
+ description: 'Block bot traffic',
+ type: 'boolean',
+ required: false,
+ },
+ excludedIPs: {
+ description: 'List of IP addresses or CIDR ranges to exclude',
+ type: 'string[]',
+ typeDescription: 'Max 100 entries',
+ required: false,
+ },
+ excludedCountries: {
+ description: 'List of country codes to exclude',
+ type: 'string[]',
+ typeDescription: '2-letter ISO codes (e.g., US, GB)',
+ required: false,
+ },
+ sessionReplay: {
+ description: 'Enable session replay',
+ type: 'boolean',
+ required: false,
+ },
+ webVitals: {
+ description: 'Enable Web Vitals tracking',
+ type: 'boolean',
+ required: false,
+ },
+ trackErrors: {
+ description: 'Enable error tracking',
+ type: 'boolean',
+ required: false,
+ },
+ trackOutbound: {
+ description: 'Enable outbound link tracking',
+ type: 'boolean',
+ required: false,
+ },
+ trackUrlParams: {
+ description: 'Enable URL parameter tracking',
+ type: 'boolean',
+ required: false,
+ },
+ }}
+/>
+
+### Response
+
+<TypeTable
+ type={{
+ success: {
+ description: 'Whether the update was successful',
+ type: 'boolean',
+ },
+ message: {
+ description: 'Status message',
+ type: 'string',
+ },
+ config: {
+ description: 'Updated site configuration',
+ type: 'object',
+ },
+ }}
+/>
+
+</div>
+<div className="flex flex-col gap-4">
+
+<Tabs items={['cURL', 'JavaScript', 'Python', 'PHP', 'Ruby', 'Go', 'Rust', 'Java', '.NET']}>
+ <Tab value="cURL">
+```bash title="Request"
+curl -X PUT "https://api.rybbit.io/api/sites/123/config" \
+ -H "Authorization: Bearer your_api_key_here" \
+ -H "Content-Type: application/json" \
+ -d '{"public": true, "blockBots": true, "excludedCountries": ["CN", "RU"]}'
+```
+ </Tab>
+ <Tab value="JavaScript">
+```javascript title="Request"
+const response = await fetch(
+ 'https://api.rybbit.io/api/sites/123/config',
+ {
+ method: 'PUT',
+ headers: {
+ 'Authorization': 'Bearer your_api_key_here',
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({
+ public: true,
+ blockBots: true,
+ excludedCountries: ['CN', 'RU']
+ })
+ }
+);
+
+const data = await response.json();
+```
+ </Tab>
+ <Tab value="Python">
+```python title="Request"
+import requests
+
+response = requests.put(
+ 'https://api.rybbit.io/api/sites/123/config',
+ json={
+ 'public': True,
+ 'blockBots': True,
+ 'excludedCountries': ['CN', 'RU']
+ },
+ headers={
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+)
+
+data = response.json()
+```
+ </Tab>
+ <Tab value="PHP">
+```php title="Request"
+$ch = curl_init();
+curl_setopt($ch, CURLOPT_URL, 'https://api.rybbit.io/api/sites/123/config');
+curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
+curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
+ 'public' => true,
+ 'blockBots' => true,
+ 'excludedCountries' => ['CN', 'RU']
+]));
+curl_setopt($ch, CURLOPT_HTTPHEADER, [
+ 'Authorization: Bearer your_api_key_here',
+ 'Content-Type: application/json'
+]);
+
+$response = curl_exec($ch);
+curl_close($ch);
+
+$data = json_decode($response, true);
+```
+ </Tab>
+ <Tab value="Ruby">
+```ruby title="Request"
+require 'net/http'
+require 'json'
+
+uri = URI('https://api.rybbit.io/api/sites/123/config')
+req = Net::HTTP::Put.new(uri)
+req['Authorization'] = 'Bearer your_api_key_here'
+req['Content-Type'] = 'application/json'
+req.body = { public: true, blockBots: true, excludedCountries: ['CN', 'RU'] }.to_json
+
+res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+data = JSON.parse(res.body)
+```
+ </Tab>
+ <Tab value="Go">
+```go title="Request"
+body := bytes.NewBuffer([]byte(`{"public": true, "blockBots": true, "excludedCountries": ["CN", "RU"]}`))
+req, _ := http.NewRequest("PUT", "https://api.rybbit.io/api/sites/123/config", body)
+req.Header.Set("Authorization", "Bearer your_api_key_here")
+req.Header.Set("Content-Type", "application/json")
+
+client := &http.Client{}
+resp, _ := client.Do(req)
+defer resp.Body.Close()
+
+var data map[string]interface{}
+json.NewDecoder(resp.Body).Decode(&data)
+```
+ </Tab>
+ <Tab value="Rust">
+```rust title="Request"
+let client = reqwest::Client::new();
+let res = client
+ .put("https://api.rybbit.io/api/sites/123/config")
+ .header("Authorization", "Bearer your_api_key_here")
+ .json(&serde_json::json!({
+ "public": true,
+ "blockBots": true,
+ "excludedCountries": ["CN", "RU"]
+ }))
+ .send()
+ .await?;
+
+let data: serde_json::Value = res.json().await?;
+```
+ </Tab>
+ <Tab value="Java">
+```java title="Request"
+HttpClient client = HttpClient.newHttpClient();
+String json = "{\"public\": true, \"blockBots\": true, \"excludedCountries\": [\"CN\", \"RU\"]}";
+HttpRequest request = HttpRequest.newBuilder()
+ .uri(URI.create("https://api.rybbit.io/api/sites/123/config"))
+ .header("Authorization", "Bearer your_api_key_here")
+ .header("Content-Type", "application/json")
+ .PUT(HttpRequest.BodyPublishers.ofString(json))
+ .build();
+
+HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+```
+ </Tab>
+ <Tab value=".NET">
+```csharp title="Request"
+using var client = new HttpClient();
+client.DefaultRequestHeaders.Add("Authorization", "Bearer your_api_key_here");
+
+var content = new StringContent(
+ "{\"public\": true, \"blockBots\": true, \"excludedCountries\": [\"CN\", \"RU\"]}",
+ Encoding.UTF8,
+ "application/json"
+);
+
+var response = await client.PutAsync("https://api.rybbit.io/api/sites/123/config", content);
+var data = await response.Content.ReadAsStringAsync();
+```
+ </Tab>
+</Tabs>
+
+```json title="Response"
+{
+ "success": true,
+ "message": "Site configuration updated successfully",
+ "config": {
+ "public": true,
+ "saltUserIds": false,
+ "blockBots": true,
+ "excludedIPs": [],
+ "excludedCountries": ["CN", "RU"],
+ "sessionReplay": true,
+ "webVitals": true,
+ "trackErrors": true,
+ "trackOutbound": true,
+ "trackUrlParams": false
+ }
+}
+```
+
+</div>
+</div>
+
+---
+
+## Get Excluded IPs
+
+<div className="grid grid-cols-1 xl:grid-cols-2 gap-8">
+<div>
+
+```
+GET /api/sites/:siteId/excluded-ips
+```
+
+Returns the list of IP addresses and CIDR ranges that are excluded from tracking.
+
+### Path Parameters
+
+<TypeTable
+ type={{
+ siteId: {
+ description: 'Site ID',
+ type: 'string | number',
+ required: true,
+ },
+ }}
+/>
+
+### Response
+
+<TypeTable
+ type={{
+ success: {
+ description: 'Whether the request was successful',
+ type: 'boolean',
+ },
+ excludedIPs: {
+ description: 'Array of excluded IP addresses or CIDR ranges',
+ type: 'string[]',
+ },
+ }}
+/>
+
+</div>
+<div className="flex flex-col gap-4">
+
+<Tabs items={['cURL', 'JavaScript', 'Python', 'PHP', 'Ruby', 'Go', 'Rust', 'Java', '.NET']}>
+ <Tab value="cURL">
+```bash title="Request"
+curl -X GET "https://api.rybbit.io/api/sites/123/excluded-ips" \
+ -H "Authorization: Bearer your_api_key_here"
+```
+ </Tab>
+ <Tab value="JavaScript">
+```javascript title="Request"
+const response = await fetch(
+ 'https://api.rybbit.io/api/sites/123/excluded-ips',
+ {
+ headers: {
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+ }
+);
+
+const data = await response.json();
+```
+ </Tab>
+ <Tab value="Python">
+```python title="Request"
+import requests
+
+response = requests.get(
+ 'https://api.rybbit.io/api/sites/123/excluded-ips',
+ headers={
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+)
+
+data = response.json()
+```
+ </Tab>
+ <Tab value="PHP">
+```php title="Request"
+$ch = curl_init();
+curl_setopt($ch, CURLOPT_URL, 'https://api.rybbit.io/api/sites/123/excluded-ips');
+curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+curl_setopt($ch, CURLOPT_HTTPHEADER, [
+ 'Authorization: Bearer your_api_key_here'
+]);
+
+$response = curl_exec($ch);
+curl_close($ch);
+
+$data = json_decode($response, true);
+```
+ </Tab>
+ <Tab value="Ruby">
+```ruby title="Request"
+require 'net/http'
+require 'json'
+
+uri = URI('https://api.rybbit.io/api/sites/123/excluded-ips')
+req = Net::HTTP::Get.new(uri)
+req['Authorization'] = 'Bearer your_api_key_here'
+
+res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+data = JSON.parse(res.body)
+```
+ </Tab>
+ <Tab value="Go">
+```go title="Request"
+req, _ := http.NewRequest("GET", "https://api.rybbit.io/api/sites/123/excluded-ips", nil)
+req.Header.Set("Authorization", "Bearer your_api_key_here")
+
+client := &http.Client{}
+resp, _ := client.Do(req)
+defer resp.Body.Close()
+
+var data map[string]interface{}
+json.NewDecoder(resp.Body).Decode(&data)
+```
+ </Tab>
+ <Tab value="Rust">
+```rust title="Request"
+let client = reqwest::Client::new();
+let res = client
+ .get("https://api.rybbit.io/api/sites/123/excluded-ips")
+ .header("Authorization", "Bearer your_api_key_here")
+ .send()
+ .await?;
+
+let data: serde_json::Value = res.json().await?;
+```
+ </Tab>
+ <Tab value="Java">
+```java title="Request"
+HttpClient client = HttpClient.newHttpClient();
+HttpRequest request = HttpRequest.newBuilder()
+ .uri(URI.create("https://api.rybbit.io/api/sites/123/excluded-ips"))
+ .header("Authorization", "Bearer your_api_key_here")
+ .GET()
+ .build();
+
+HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+```
+ </Tab>
+ <Tab value=".NET">
+```csharp title="Request"
+using var client = new HttpClient();
+client.DefaultRequestHeaders.Add("Authorization", "Bearer your_api_key_here");
+
+var response = await client.GetAsync("https://api.rybbit.io/api/sites/123/excluded-ips");
+var data = await response.Content.ReadAsStringAsync();
+```
+ </Tab>
+</Tabs>
+
+```json title="Response"
+{
+ "success": true,
+ "excludedIPs": [
+ "192.168.1.1",
+ "10.0.0.0/8",
+ "172.16.0.0/12"
+ ]
+}
+```
+
+</div>
+</div>
+
+---
+
+## Get Excluded Countries
+
+<div className="grid grid-cols-1 xl:grid-cols-2 gap-8">
+<div>
+
+```
+GET /api/sites/:siteId/excluded-countries
+```
+
+Returns the list of country codes that are excluded from tracking.
+
+### Path Parameters
+
+<TypeTable
+ type={{
+ siteId: {
+ description: 'Site ID',
+ type: 'string | number',
+ required: true,
+ },
+ }}
+/>
+
+### Response
+
+<TypeTable
+ type={{
+ success: {
+ description: 'Whether the request was successful',
+ type: 'boolean',
+ },
+ excludedCountries: {
+ description: 'Array of excluded country codes (2-letter ISO codes)',
+ type: 'string[]',
+ },
+ }}
+/>
+
+</div>
+<div className="flex flex-col gap-4">
+
+<Tabs items={['cURL', 'JavaScript', 'Python', 'PHP', 'Ruby', 'Go', 'Rust', 'Java', '.NET']}>
+ <Tab value="cURL">
+```bash title="Request"
+curl -X GET "https://api.rybbit.io/api/sites/123/excluded-countries" \
+ -H "Authorization: Bearer your_api_key_here"
+```
+ </Tab>
+ <Tab value="JavaScript">
+```javascript title="Request"
+const response = await fetch(
+ 'https://api.rybbit.io/api/sites/123/excluded-countries',
+ {
+ headers: {
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+ }
+);
+
+const data = await response.json();
+```
+ </Tab>
+ <Tab value="Python">
+```python title="Request"
+import requests
+
+response = requests.get(
+ 'https://api.rybbit.io/api/sites/123/excluded-countries',
+ headers={
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+)
+
+data = response.json()
+```
+ </Tab>
+ <Tab value="PHP">
+```php title="Request"
+$ch = curl_init();
+curl_setopt($ch, CURLOPT_URL, 'https://api.rybbit.io/api/sites/123/excluded-countries');
+curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+curl_setopt($ch, CURLOPT_HTTPHEADER, [
+ 'Authorization: Bearer your_api_key_here'
+]);
+
+$response = curl_exec($ch);
+curl_close($ch);
+
+$data = json_decode($response, true);
+```
+ </Tab>
+ <Tab value="Ruby">
+```ruby title="Request"
+require 'net/http'
+require 'json'
+
+uri = URI('https://api.rybbit.io/api/sites/123/excluded-countries')
+req = Net::HTTP::Get.new(uri)
+req['Authorization'] = 'Bearer your_api_key_here'
+
+res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+data = JSON.parse(res.body)
+```
+ </Tab>
+ <Tab value="Go">
+```go title="Request"
+req, _ := http.NewRequest("GET", "https://api.rybbit.io/api/sites/123/excluded-countries", nil)
+req.Header.Set("Authorization", "Bearer your_api_key_here")
+
+client := &http.Client{}
+resp, _ := client.Do(req)
+defer resp.Body.Close()
+
+var data map[string]interface{}
+json.NewDecoder(resp.Body).Decode(&data)
+```
+ </Tab>
+ <Tab value="Rust">
+```rust title="Request"
+let client = reqwest::Client::new();
+let res = client
+ .get("https://api.rybbit.io/api/sites/123/excluded-countries")
+ .header("Authorization", "Bearer your_api_key_here")
+ .send()
+ .await?;
+
+let data: serde_json::Value = res.json().await?;
+```
+ </Tab>
+ <Tab value="Java">
+```java title="Request"
+HttpClient client = HttpClient.newHttpClient();
+HttpRequest request = HttpRequest.newBuilder()
+ .uri(URI.create("https://api.rybbit.io/api/sites/123/excluded-countries"))
+ .header("Authorization", "Bearer your_api_key_here")
+ .GET()
+ .build();
+
+HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+```
+ </Tab>
+ <Tab value=".NET">
+```csharp title="Request"
+using var client = new HttpClient();
+client.DefaultRequestHeaders.Add("Authorization", "Bearer your_api_key_here");
+
+var response = await client.GetAsync("https://api.rybbit.io/api/sites/123/excluded-countries");
+var data = await response.Content.ReadAsStringAsync();
+```
+ </Tab>
+</Tabs>
+
+```json title="Response"
+{
+ "success": true,
+ "excludedCountries": [
+ "CN",
+ "RU",
+ "KP"
+ ]
+}
+```
+
+</div>
+</div>
+
+---
+
+## Get Private Link Config
+
+<div className="grid grid-cols-1 xl:grid-cols-2 gap-8">
+<div>
+
+```
+GET /api/sites/:siteId/private-link-config
+```
+
+Returns the private link key configuration. Private links allow sharing analytics with a secret key without requiring authentication.
+
+### Path Parameters
+
+<TypeTable
+ type={{
+ siteId: {
+ description: 'Site ID',
+ type: 'string | number',
+ required: true,
+ },
+ }}
+/>
+
+### Response
+
+<TypeTable
+ type={{
+ success: {
+ description: 'Whether the request was successful',
+ type: 'boolean',
+ },
+ data: {
+ description: 'Private link configuration',
+ type: 'object',
+ },
+ }}
+/>
+
+#### Data Object
+
+<TypeTable
+ type={{
+ privateLinkKey: {
+ description: 'Private link key, or null if not generated',
+ type: 'string | null',
+ },
+ }}
+/>
+
+</div>
+<div className="flex flex-col gap-4">
+
+<Tabs items={['cURL', 'JavaScript', 'Python', 'PHP', 'Ruby', 'Go', 'Rust', 'Java', '.NET']}>
+ <Tab value="cURL">
+```bash title="Request"
+curl -X GET "https://api.rybbit.io/api/sites/123/private-link-config" \
+ -H "Authorization: Bearer your_api_key_here"
+```
+ </Tab>
+ <Tab value="JavaScript">
+```javascript title="Request"
+const response = await fetch(
+ 'https://api.rybbit.io/api/sites/123/private-link-config',
+ {
+ headers: {
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+ }
+);
+
+const data = await response.json();
+```
+ </Tab>
+ <Tab value="Python">
+```python title="Request"
+import requests
+
+response = requests.get(
+ 'https://api.rybbit.io/api/sites/123/private-link-config',
+ headers={
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+)
+
+data = response.json()
+```
+ </Tab>
+ <Tab value="PHP">
+```php title="Request"
+$ch = curl_init();
+curl_setopt($ch, CURLOPT_URL, 'https://api.rybbit.io/api/sites/123/private-link-config');
+curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+curl_setopt($ch, CURLOPT_HTTPHEADER, [
+ 'Authorization: Bearer your_api_key_here'
+]);
+
+$response = curl_exec($ch);
+curl_close($ch);
+
+$data = json_decode($response, true);
+```
+ </Tab>
+ <Tab value="Ruby">
+```ruby title="Request"
+require 'net/http'
+require 'json'
+
+uri = URI('https://api.rybbit.io/api/sites/123/private-link-config')
+req = Net::HTTP::Get.new(uri)
+req['Authorization'] = 'Bearer your_api_key_here'
+
+res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+data = JSON.parse(res.body)
+```
+ </Tab>
+ <Tab value="Go">
+```go title="Request"
+req, _ := http.NewRequest("GET", "https://api.rybbit.io/api/sites/123/private-link-config", nil)
+req.Header.Set("Authorization", "Bearer your_api_key_here")
+
+client := &http.Client{}
+resp, _ := client.Do(req)
+defer resp.Body.Close()
+
+var data map[string]interface{}
+json.NewDecoder(resp.Body).Decode(&data)
+```
+ </Tab>
+ <Tab value="Rust">
+```rust title="Request"
+let client = reqwest::Client::new();
+let res = client
+ .get("https://api.rybbit.io/api/sites/123/private-link-config")
+ .header("Authorization", "Bearer your_api_key_here")
+ .send()
+ .await?;
+
+let data: serde_json::Value = res.json().await?;
+```
+ </Tab>
+ <Tab value="Java">
+```java title="Request"
+HttpClient client = HttpClient.newHttpClient();
+HttpRequest request = HttpRequest.newBuilder()
+ .uri(URI.create("https://api.rybbit.io/api/sites/123/private-link-config"))
+ .header("Authorization", "Bearer your_api_key_here")
+ .GET()
+ .build();
+
+HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+```
+ </Tab>
+ <Tab value=".NET">
+```csharp title="Request"
+using var client = new HttpClient();
+client.DefaultRequestHeaders.Add("Authorization", "Bearer your_api_key_here");
+
+var response = await client.GetAsync("https://api.rybbit.io/api/sites/123/private-link-config");
+var data = await response.Content.ReadAsStringAsync();
+```
+ </Tab>
+</Tabs>
+
+```json title="Response"
+{
+ "success": true,
+ "data": {
+ "privateLinkKey": "a1b2c3d4e5f6"
+ }
+}
+```
+
+</div>
+</div>
+
+---
+
+## Update Private Link Config
+
+<div className="grid grid-cols-1 xl:grid-cols-2 gap-8">
+<div>
+
+```
+POST /api/sites/:siteId/private-link-config
+```
+
+Generates or revokes a private link key for sharing analytics without authentication. Requires admin or owner role.
+
+### Path Parameters
+
+<TypeTable
+ type={{
+ siteId: {
+ description: 'Site ID',
+ type: 'string | number',
+ required: true,
+ },
+ }}
+/>
+
+### Request Body
+
+<TypeTable
+ type={{
+ action: {
+ description: 'Action to perform',
+ type: 'string',
+ typeDescription: '"generate_private_link_key" | "revoke_private_link_key"',
+ required: true,
+ },
+ }}
+/>
+
+### Response
+
+<TypeTable
+ type={{
+ success: {
+ description: 'Whether the request was successful',
+ type: 'boolean',
+ },
+ data: {
+ description: 'Updated private link configuration',
+ type: 'object',
+ },
+ }}
+/>
+
+#### Data Object
+
+<TypeTable
+ type={{
+ privateLinkKey: {
+ description: 'New private link key (for generate), or null (for revoke)',
+ type: 'string | null',
+ },
+ }}
+/>
+
+</div>
+<div className="flex flex-col gap-4">
+
+<Tabs items={['cURL', 'JavaScript', 'Python', 'PHP', 'Ruby', 'Go', 'Rust', 'Java', '.NET']}>
+ <Tab value="cURL">
+```bash title="Request"
+curl -X POST "https://api.rybbit.io/api/sites/123/private-link-config" \
+ -H "Authorization: Bearer your_api_key_here" \
+ -H "Content-Type: application/json" \
+ -d '{"action": "generate_private_link_key"}'
+```
+ </Tab>
+ <Tab value="JavaScript">
+```javascript title="Request"
+const response = await fetch(
+ 'https://api.rybbit.io/api/sites/123/private-link-config',
+ {
+ method: 'POST',
+ headers: {
+ 'Authorization': 'Bearer your_api_key_here',
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({
+ action: 'generate_private_link_key'
+ })
+ }
+);
+
+const data = await response.json();
+```
+ </Tab>
+ <Tab value="Python">
+```python title="Request"
+import requests
+
+response = requests.post(
+ 'https://api.rybbit.io/api/sites/123/private-link-config',
+ json={
+ 'action': 'generate_private_link_key'
+ },
+ headers={
+ 'Authorization': 'Bearer your_api_key_here'
+ }
+)
+
+data = response.json()
+```
+ </Tab>
+ <Tab value="PHP">
+```php title="Request"
+$ch = curl_init();
+curl_setopt($ch, CURLOPT_URL, 'https://api.rybbit.io/api/sites/123/private-link-config');
+curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+curl_setopt($ch, CURLOPT_POST, true);
+curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
+ 'action' => 'generate_private_link_key'
+]));
+curl_setopt($ch, CURLOPT_HTTPHEADER, [
+ 'Authorization: Bearer your_api_key_here',
+ 'Content-Type: application/json'
+]);
+
+$response = curl_exec($ch);
+curl_close($ch);
+
+$data = json_decode($response, true);
+```
+ </Tab>
+ <Tab value="Ruby">
+```ruby title="Request"
+require 'net/http'
+require 'json'
+
+uri = URI('https://api.rybbit.io/api/sites/123/private-link-config')
+req = Net::HTTP::Post.new(uri)
+req['Authorization'] = 'Bearer your_api_key_here'
+req['Content-Type'] = 'application/json'
+req.body = { action: 'generate_private_link_key' }.to_json
+
+res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+data = JSON.parse(res.body)
+```
+ </Tab>
+ <Tab value="Go">
+```go title="Request"
+body := bytes.NewBuffer([]byte(`{"action": "generate_private_link_key"}`))
+req, _ := http.NewRequest("POST", "https://api.rybbit.io/api/sites/123/private-link-config", body)
+req.Header.Set("Authorization", "Bearer your_api_key_here")
+req.Header.Set("Content-Type", "application/json")
+
+client := &http.Client{}
+resp, _ := client.Do(req)
+defer resp.Body.Close()
+
+var data map[string]interface{}
+json.NewDecoder(resp.Body).Decode(&data)
+```
+ </Tab>
+ <Tab value="Rust">
+```rust title="Request"
+let client = reqwest::Client::new();
+let res = client
+ .post("https://api.rybbit.io/api/sites/123/private-link-config")
+ .header("Authorization", "Bearer your_api_key_here")
+ .json(&serde_json::json!({
+ "action": "generate_private_link_key"
+ }))
+ .send()
+ .await?;
+
+let data: serde_json::Value = res.json().await?;
+```
+ </Tab>
+ <Tab value="Java">
+```java title="Request"
+HttpClient client = HttpClient.newHttpClient();
+String json = "{\"action\": \"generate_private_link_key\"}";
+HttpRequest request = HttpRequest.newBuilder()
+ .uri(URI.create("https://api.rybbit.io/api/sites/123/private-link-config"))
+ .header("Authorization", "Bearer your_api_key_here")
+ .header("Content-Type", "application/json")
+ .POST(HttpRequest.BodyPublishers.ofString(json))
+ .build();
+
+HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+```
+ </Tab>
+ <Tab value=".NET">
+```csharp title="Request"
+using var client = new HttpClient();
+client.DefaultRequestHeaders.Add("Authorization", "Bearer your_api_key_here");
+
+var content = new StringContent(
+ "{\"action\": \"generate_private_link_key\"}",
+ Encoding.UTF8,
+ "application/json"
+);
+
+var response = await client.PostAsync("https://api.rybbit.io/api/sites/123/private-link-config", content);
+var data = await response.Content.ReadAsStringAsync();
+```
+ </Tab>
+</Tabs>
+
+```json title="Response"
+{
+ "success": true,
+ "data": {
+ "privateLinkKey": "f6e5d4c3b2a1"
+ }
+}
+```
+
+</div>
+</div>
diff --git a/server/src/api/admin/getAdminOrganizations.ts b/server/src/api/admin/getAdminOrganizations.ts
index 9c600e233..e6658f78d 100644
--- a/server/src/api/admin/getAdminOrganizations.ts
+++ b/server/src/api/admin/getAdminOrganizations.ts
@@ -4,11 +4,9 @@ import { DateTime } from "luxon";
import { clickhouse } from "../../db/clickhouse/clickhouse.js";
import { db } from "../../db/postgres/postgres.js";
import { member, sites, user } from "../../db/postgres/schema.js";
-import { getIsUserAdmin } from "../../lib/auth-utils.js";
import { logger } from "../../lib/logger/logger.js";
import { getOrganizationSubscriptions } from "../../services/admin/subscriptionService.js";
-// Define event count result type
interface EventCountResult {
site_id: string;
total_events: number;
@@ -47,12 +45,6 @@ export interface AdminOrganizationData {
}
export async function getAdminOrganizations(request: FastifyRequest, reply: FastifyReply) {
- const isAdmin = await getIsUserAdmin(request);
-
- if (!isAdmin) {
- return reply.status(401).send({ error: "Unauthorized" });
- }
-
try {
// Get all organizations with their basic data
const organizationsData = await db.query.organization.findMany({
diff --git a/server/src/api/admin/getAdminServiceEventCount.ts b/server/src/api/admin/getAdminServiceEventCount.ts
index fe48e4da3..e430440cb 100644
--- a/server/src/api/admin/getAdminServiceEventCount.ts
+++ b/server/src/api/admin/getAdminServiceEventCount.ts
@@ -1,7 +1,6 @@
import { FastifyReply, FastifyRequest } from "fastify";
import SqlString from "sqlstring";
import { clickhouse } from "../../db/clickhouse/clickhouse.js";
-import { getIsUserAdmin } from "../../lib/auth-utils.js";
import { processResults } from "../analytics/utils/utils.js";
type ServiceEventCountResponse = {
@@ -22,12 +21,6 @@ export async function getAdminServiceEventCount(
}>,
res: FastifyReply
) {
- const isAdmin = await getIsUserAdmin(req);
-
- if (!isAdmin) {
- return res.status(401).send({ error: "Unauthorized" });
- }
-
const { start_date, end_date, time_zone = "UTC" } = req.query;
try {
diff --git a/server/src/api/admin/getAdminSites.ts b/server/src/api/admin/getAdminSites.ts
index 5d853431b..c27076541 100644
--- a/server/src/api/admin/getAdminSites.ts
+++ b/server/src/api/admin/getAdminSites.ts
@@ -4,22 +4,14 @@ import { DateTime } from "luxon";
import { clickhouse } from "../../db/clickhouse/clickhouse.js";
import { db } from "../../db/postgres/postgres.js";
import { member, user } from "../../db/postgres/schema.js";
-import { getIsUserAdmin } from "../../lib/auth-utils.js";
import { getOrganizationSubscriptions } from "../../services/admin/subscriptionService.js";
-// Define event count result type
interface EventCountResult {
site_id: string;
total_events: number;
}
export async function getAdminSites(request: FastifyRequest, reply: FastifyReply) {
- const isAdmin = await getIsUserAdmin(request);
-
- if (!isAdmin) {
- return reply.status(401).send({ error: "Unauthorized" });
- }
-
// Get all sites (including organizationId for owner lookup)
const sitesData = await db.query.sites.findMany({
orderBy: (sites, { desc }) => [desc(sites.createdAt)],
diff --git a/server/src/api/analytics/events/getEventNames.ts b/server/src/api/analytics/events/getEventNames.ts
index 2dd98f317..829f80486 100644
--- a/server/src/api/analytics/events/getEventNames.ts
+++ b/server/src/api/analytics/events/getEventNames.ts
@@ -11,7 +11,7 @@ export type GetEventNamesResponse = {
export interface GetEventNamesRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
event_name: string;
@@ -20,7 +20,7 @@ export interface GetEventNamesRequest {
export async function getEventNames(req: FastifyRequest<GetEventNamesRequest>, res: FastifyReply) {
const { filters } = req.query;
- const site = req.params.site;
+ const site = req.params.siteId;
const timeStatement = getTimeStatement(req.query);
diff --git a/server/src/api/analytics/events/getEventProperties.ts b/server/src/api/analytics/events/getEventProperties.ts
index ee186f423..d0a93e42d 100644
--- a/server/src/api/analytics/events/getEventProperties.ts
+++ b/server/src/api/analytics/events/getEventProperties.ts
@@ -12,7 +12,7 @@ export type GetEventPropertiesResponse = {
export interface GetEventPropertiesRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
event_name: string;
@@ -21,7 +21,7 @@ export interface GetEventPropertiesRequest {
export async function getEventProperties(req: FastifyRequest<GetEventPropertiesRequest>, res: FastifyReply) {
const { event_name: eventName, filters } = req.query;
- const site = req.params.site;
+ const site = req.params.siteId;
if (!eventName) {
return res.status(400).send({ error: "Event name is required" });
diff --git a/server/src/api/analytics/events/getEvents.ts b/server/src/api/analytics/events/getEvents.ts
index 6d93ab033..f712a5a08 100644
--- a/server/src/api/analytics/events/getEvents.ts
+++ b/server/src/api/analytics/events/getEvents.ts
@@ -23,7 +23,7 @@ export type GetEventsResponse = {
interface GetEventsRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
page?: string;
@@ -33,7 +33,7 @@ interface GetEventsRequest {
}
export async function getEvents(req: FastifyRequest<GetEventsRequest>, res: FastifyReply) {
- const { site } = req.params;
+ const { siteId } = req.params;
const { start_date, end_date, time_zone, filters, page = "1", page_size: pageSize = "20", count } = req.query;
// Use count if provided (for backward compatibility), otherwise use page_size
@@ -44,7 +44,7 @@ export async function getEvents(req: FastifyRequest<GetEventsRequest>, res: Fast
const timeStatement =
start_date || end_date ? getTimeStatement(req.query) : "AND timestamp > now() - INTERVAL 30 MINUTE"; // Default to last 30 minutes if no time range specified
- const filterStatement = filters ? getFilterStatement(filters, Number(site), timeStatement) : "";
+ const filterStatement = filters ? getFilterStatement(filters, Number(siteId), timeStatement) : "";
try {
// First, get the total count for pagination metadata
@@ -63,7 +63,7 @@ export async function getEvents(req: FastifyRequest<GetEventsRequest>, res: Fast
query: countQuery,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
},
});
@@ -101,7 +101,7 @@ export async function getEvents(req: FastifyRequest<GetEventsRequest>, res: Fast
query: eventsQuery,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
limit: Number(limit),
offset: Number(offset),
},
diff --git a/server/src/api/analytics/events/getOutboundLinks.ts b/server/src/api/analytics/events/getOutboundLinks.ts
index 18fc5be1e..9e196baee 100644
--- a/server/src/api/analytics/events/getOutboundLinks.ts
+++ b/server/src/api/analytics/events/getOutboundLinks.ts
@@ -12,14 +12,14 @@ export type GetOutboundLinksResponse = {
export interface GetOutboundLinksRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{}>;
}
export async function getOutboundLinks(req: FastifyRequest<GetOutboundLinksRequest>, res: FastifyReply) {
const { filters } = req.query;
- const site = req.params.site;
+ const site = req.params.siteId;
const timeStatement = getTimeStatement(req.query);
const filterStatement = filters ? getFilterStatement(filters, Number(site), timeStatement) : "";
diff --git a/server/src/api/analytics/funnels/createFunnel.ts b/server/src/api/analytics/funnels/createFunnel.ts
index b56969fbd..0d9342c3b 100644
--- a/server/src/api/analytics/funnels/createFunnel.ts
+++ b/server/src/api/analytics/funnels/createFunnel.ts
@@ -21,13 +21,13 @@ export async function createFunnel(
request: FastifyRequest<{
Body: Funnel;
Params: {
- site: string;
+ siteId: string;
};
}>,
reply: FastifyReply
) {
const { steps, name, reportId } = request.body;
- const { site } = request.params;
+ const { siteId } = request.params;
const userId = request.user?.id;
// Validate request
@@ -40,7 +40,7 @@ export async function createFunnel(
}
// Check user access to site
- const userHasAccessToSite = await getUserHasAccessToSite(request, site);
+ const userHasAccessToSite = await getUserHasAccessToSite(request, siteId);
if (!userHasAccessToSite) {
return reply.status(403).send({ error: "Forbidden" });
}
@@ -58,7 +58,7 @@ export async function createFunnel(
return reply.status(404).send({ error: "Funnel not found" });
}
- if (existingFunnel.siteId !== Number(site)) {
+ if (existingFunnel.siteId !== Number(siteId)) {
return reply.status(403).send({ error: "Funnel does not belong to this site" });
}
@@ -83,7 +83,7 @@ export async function createFunnel(
result = await db
.insert(funnelsTable)
.values({
- siteId: Number(site),
+ siteId: Number(siteId),
userId,
data: {
name,
diff --git a/server/src/api/analytics/funnels/getFunnel.ts b/server/src/api/analytics/funnels/getFunnel.ts
index 8ad158edd..66bcde1ce 100644
--- a/server/src/api/analytics/funnels/getFunnel.ts
+++ b/server/src/api/analytics/funnels/getFunnel.ts
@@ -30,14 +30,14 @@ export async function getFunnel(
request: FastifyRequest<{
Body: Funnel;
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{}>;
}>,
reply: FastifyReply
) {
const { steps } = request.body;
- const { site } = request.params;
+ const { siteId } = request.params;
// Validate request
if (!steps || steps.length < 2) {
@@ -46,7 +46,7 @@ export async function getFunnel(
try {
const timeStatement = getTimeStatement(request.query);
- const filterStatement = getFilterStatement(request.query.filters, Number(site), timeStatement);
+ const filterStatement = getFilterStatement(request.query.filters, Number(siteId), timeStatement);
// Build conditional statements for each step
const stepConditions = steps.map(step => {
@@ -180,7 +180,7 @@ export async function getFunnel(
query,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
stepNumber: steps.length,
},
});
diff --git a/server/src/api/analytics/funnels/getFunnelStepSessions.ts b/server/src/api/analytics/funnels/getFunnelStepSessions.ts
index a418adb63..bbc3e8da4 100644
--- a/server/src/api/analytics/funnels/getFunnelStepSessions.ts
+++ b/server/src/api/analytics/funnels/getFunnelStepSessions.ts
@@ -22,7 +22,7 @@ type Funnel = {
export interface GetFunnelStepSessionsRequest {
Body: Funnel;
Params: {
- site: string;
+ siteId: string;
stepNumber: string;
};
Querystring: FilterParams<{
@@ -34,7 +34,7 @@ export interface GetFunnelStepSessionsRequest {
export async function getFunnelStepSessions(req: FastifyRequest<GetFunnelStepSessionsRequest>, res: FastifyReply) {
const { steps } = req.body;
- const { stepNumber: stepNumberStr, site } = req.params;
+ const { stepNumber: stepNumberStr, siteId } = req.params;
const { mode, page, limit } = req.query;
const stepNumber = parseInt(stepNumberStr, 10);
@@ -59,7 +59,7 @@ export async function getFunnelStepSessions(req: FastifyRequest<GetFunnelStepSes
try {
const timeStatement = getTimeStatement(req.query);
- let filterStatement = getFilterStatement(req.query.filters, Number(site), timeStatement);
+ let filterStatement = getFilterStatement(req.query.filters, Number(siteId), timeStatement);
// Transform filter statement to use extracted UTM columns instead of map access
// since the CTE already extracts utm_source, utm_medium, etc. as separate columns
@@ -231,7 +231,7 @@ export async function getFunnelStepSessions(req: FastifyRequest<GetFunnelStepSes
query,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
limit: limit || 25,
offset: (page - 1) * (limit || 25),
},
diff --git a/server/src/api/analytics/funnels/getFunnels.ts b/server/src/api/analytics/funnels/getFunnels.ts
index 766d6a5ba..9f3a859aa 100644
--- a/server/src/api/analytics/funnels/getFunnels.ts
+++ b/server/src/api/analytics/funnels/getFunnels.ts
@@ -6,19 +6,19 @@ import { funnels as funnelsTable } from "../../../db/postgres/schema.js";
export async function getFunnels(
request: FastifyRequest<{
Params: {
- site: string;
+ siteId: string;
};
}>,
reply: FastifyReply
) {
- const { site } = request.params;
+ const { siteId } = request.params;
try {
// Fetch all funnels for the site
const funnelRecords = await db
.select()
.from(funnelsTable)
- .where(eq(funnelsTable.siteId, Number(site)))
+ .where(eq(funnelsTable.siteId, Number(siteId)))
.orderBy(funnelsTable.createdAt);
// Transform the records to a more frontend-friendly structure
diff --git a/server/src/api/analytics/getErrorBucketed.ts b/server/src/api/analytics/getErrorBucketed.ts
index cda571bce..e18a9871f 100644
--- a/server/src/api/analytics/getErrorBucketed.ts
+++ b/server/src/api/analytics/getErrorBucketed.ts
@@ -35,7 +35,7 @@ function getTimeStatementFill(params: FilterParams, bucket: TimeBucket) {
interface GetErrorBucketedRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
bucket: TimeBucket;
@@ -49,7 +49,7 @@ export type GetErrorBucketedResponse = {
}[];
export async function getErrorBucketed(req: FastifyRequest<GetErrorBucketedRequest>, res: FastifyReply) {
- const site = req.params.site;
+ const site = req.params.siteId;
const { bucket, errorMessage } = req.query;
if (!errorMessage) {
diff --git a/server/src/api/analytics/getErrorEvents.ts b/server/src/api/analytics/getErrorEvents.ts
index f8015bb8c..548f3548b 100644
--- a/server/src/api/analytics/getErrorEvents.ts
+++ b/server/src/api/analytics/getErrorEvents.ts
@@ -6,7 +6,7 @@ import { getFilterStatement } from "./utils/getFilterStatement.js";
interface GetErrorEventsRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
errorMessage: string;
@@ -50,7 +50,7 @@ const getErrorEventsQuery = (request: FastifyRequest<GetErrorEventsRequest>, isC
const { filters, limit, page } = request.query;
const timeStatement = getTimeStatement(request.query);
- const filterStatement = getFilterStatement(filters, Number(request.params.site), timeStatement);
+ const filterStatement = getFilterStatement(filters, Number(request.params.siteId), timeStatement);
let validatedLimit: number | null = null;
if (!isCountQuery && limit !== undefined) {
@@ -132,7 +132,7 @@ const getErrorEventsQuery = (request: FastifyRequest<GetErrorEventsRequest>, isC
};
export async function getErrorEvents(req: FastifyRequest<GetErrorEventsRequest>, res: FastifyReply) {
- const site = req.params.site;
+ const site = req.params.siteId;
const { errorMessage, page } = req.query;
if (!errorMessage) {
diff --git a/server/src/api/analytics/getErrorNames.ts b/server/src/api/analytics/getErrorNames.ts
index 8447eb1f5..0426006a2 100644
--- a/server/src/api/analytics/getErrorNames.ts
+++ b/server/src/api/analytics/getErrorNames.ts
@@ -6,7 +6,7 @@ import { getFilterStatement } from "./utils/getFilterStatement.js";
interface GetErrorNamesRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
limit?: number;
@@ -33,7 +33,7 @@ const getErrorNamesQuery = (request: FastifyRequest<GetErrorNamesRequest>, isCou
const { filters, limit, page } = request.query;
const timeStatement = getTimeStatement(request.query);
- const filterStatement = getFilterStatement(filters, Number(request.params.site), timeStatement);
+ const filterStatement = getFilterStatement(filters, Number(request.params.siteId), timeStatement);
let validatedLimit: number | null = null;
if (!isCountQuery && limit !== undefined) {
@@ -104,7 +104,7 @@ const getErrorNamesQuery = (request: FastifyRequest<GetErrorNamesRequest>, isCou
};
export async function getErrorNames(req: FastifyRequest<GetErrorNamesRequest>, res: FastifyReply) {
- const site = req.params.site;
+ const site = req.params.siteId;
const { page } = req.query;
const isPaginatedRequest = page !== undefined; // True if page is present
diff --git a/server/src/api/analytics/getJourneys.ts b/server/src/api/analytics/getJourneys.ts
index f8d06e728..c10024bab 100644
--- a/server/src/api/analytics/getJourneys.ts
+++ b/server/src/api/analytics/getJourneys.ts
@@ -6,7 +6,7 @@ import { getTimeStatement } from "./utils/utils.js";
export const getJourneys = async (
request: FastifyRequest<{
- Params: { site: string };
+ Params: { siteId: string };
Querystring: FilterParams<{
steps?: string;
limit?: string;
@@ -16,7 +16,7 @@ export const getJourneys = async (
reply: FastifyReply
) => {
try {
- const { site } = request.params;
+ const { siteId } = request.params;
const { steps = "3", limit = "100", filters, stepFilters } = request.query;
const maxSteps = parseInt(steps, 10);
@@ -36,7 +36,7 @@ export const getJourneys = async (
// Time conditions using getTimeStatement
const timeStatement = getTimeStatement(request.query);
- const filterStatement = getFilterStatement(filters, Number(site), timeStatement);
+ const filterStatement = getFilterStatement(filters, Number(siteId), timeStatement);
// Parse step filters
let parsedStepFilters: Record<number, string> = {};
@@ -106,7 +106,7 @@ export const getJourneys = async (
FROM journey_segments
`,
query_params: {
- siteId: parseInt(site, 10),
+ siteId: parseInt(siteId, 10),
maxSteps: maxSteps,
journeyLimit: journeyLimit,
},
diff --git a/server/src/api/analytics/getLiveUsercount.ts b/server/src/api/analytics/getLiveUsercount.ts
index 619c9b2cf..37a11048b 100644
--- a/server/src/api/analytics/getLiveUsercount.ts
+++ b/server/src/api/analytics/getLiveUsercount.ts
@@ -4,19 +4,19 @@ import { processResults } from "./utils/utils.js";
export const getLiveUsercount = async (
req: FastifyRequest<{
- Params: { site: string };
+ Params: { siteId: string };
Querystring: { minutes: number };
}>,
res: FastifyReply
) => {
- const { site } = req.params;
+ const { siteId } = req.params;
const { minutes } = req.query;
const query = await clickhouse.query({
query: `SELECT COUNT(DISTINCT(session_id)) AS count FROM events WHERE timestamp > now() - interval {minutes:Int32} minute AND site_id = {siteId:Int32}`,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
minutes: Number(minutes || 5),
},
});
diff --git a/server/src/api/analytics/getMetric.ts b/server/src/api/analytics/getMetric.ts
index 1193b0f04..5e4abb400 100644
--- a/server/src/api/analytics/getMetric.ts
+++ b/server/src/api/analytics/getMetric.ts
@@ -7,7 +7,7 @@ import { FilterParams } from "@rybbit/shared";
interface GetMetricRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
parameter: FilterParameter;
@@ -51,7 +51,7 @@ type GetMetricPaginatedResponse = {
const getQuery = (request: FastifyRequest<GetMetricRequest>, isCountQuery: boolean = false) => {
const { filters, parameter, limit, page } = request.query;
- const site = request.params.site;
+ const site = request.params.siteId;
const timeStatement = getTimeStatement(request.query);
@@ -397,7 +397,7 @@ const getQuery = (request: FastifyRequest<GetMetricRequest>, isCountQuery: boole
export async function getMetric(req: FastifyRequest<GetMetricRequest>, res: FastifyReply) {
const { parameter, page } = req.query;
- const site = req.params.site;
+ const site = req.params.siteId;
const isPaginatedRequest = page !== undefined;
diff --git a/server/src/api/analytics/getOverview.ts b/server/src/api/analytics/getOverview.ts
index 47cf1d865..5a84ff83e 100644
--- a/server/src/api/analytics/getOverview.ts
+++ b/server/src/api/analytics/getOverview.ts
@@ -87,14 +87,14 @@ const getQuery = (params: FilterParams, siteId: number) => {
export interface OverviewRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams;
}
export async function getOverview(req: FastifyRequest<OverviewRequest>, res: FastifyReply) {
const { start_date, end_date, time_zone, filters, past_minutes_start, past_minutes_end } = req.query;
- const site = req.params.site;
+ const site = req.params.siteId;
const query = getQuery(
{
diff --git a/server/src/api/analytics/getOverviewBucketed.ts b/server/src/api/analytics/getOverviewBucketed.ts
index 1558a1bae..c5ae63de8 100644
--- a/server/src/api/analytics/getOverviewBucketed.ts
+++ b/server/src/api/analytics/getOverviewBucketed.ts
@@ -157,7 +157,7 @@ type getOverviewBucketed = { time: string; pageviews: number }[];
export async function getOverviewBucketed(
req: FastifyRequest<{
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
bucket: TimeBucket;
@@ -166,7 +166,7 @@ export async function getOverviewBucketed(
res: FastifyReply
) {
const { start_date, end_date, time_zone, bucket, filters, past_minutes_start, past_minutes_end } = req.query;
- const site = req.params.site;
+ const site = req.params.siteId;
const query = getQuery(
{
diff --git a/server/src/api/analytics/getPageTitles.ts b/server/src/api/analytics/getPageTitles.ts
index a3b22513d..d04fda2d8 100644
--- a/server/src/api/analytics/getPageTitles.ts
+++ b/server/src/api/analytics/getPageTitles.ts
@@ -6,7 +6,7 @@ import { getFilterStatement } from "./utils/getFilterStatement.js";
interface GetPageTitlesRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
limit?: number;
@@ -33,7 +33,7 @@ const getPageTitlesQuery = (request: FastifyRequest<GetPageTitlesRequest>, isCou
const { filters, limit, page } = request.query;
const timeStatement = getTimeStatement(request.query);
- const filterStatement = getFilterStatement(filters, Number(request.params.site), timeStatement);
+ const filterStatement = getFilterStatement(filters, Number(request.params.siteId), timeStatement);
let validatedLimit: number | null = null;
if (!isCountQuery && limit !== undefined) {
@@ -122,7 +122,7 @@ const getPageTitlesQuery = (request: FastifyRequest<GetPageTitlesRequest>, isCou
};
export async function getPageTitles(req: FastifyRequest<GetPageTitlesRequest>, res: FastifyReply) {
- const site = req.params.site;
+ const site = req.params.siteId;
const { page } = req.query;
const isPaginatedRequest = page !== undefined; // True if page is present
diff --git a/server/src/api/analytics/getRetention.ts b/server/src/api/analytics/getRetention.ts
index 9a2c7d489..07d1a374f 100644
--- a/server/src/api/analytics/getRetention.ts
+++ b/server/src/api/analytics/getRetention.ts
@@ -21,12 +21,12 @@ interface ProcessedRetentionData {
export const getRetention = async (
req: FastifyRequest<{
- Params: { site: string };
+ Params: { siteId: string };
Querystring: { mode?: string; range?: string };
}>,
res: FastifyReply
) => {
- const { site } = req.params;
+ const { siteId } = req.params;
const { mode = "week", range = "90" } = req.query; // Default to weekly mode and 90 days range
// Validate mode parameter
@@ -94,7 +94,7 @@ ORDER BY
`,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
timeRange: timeRange,
},
});
diff --git a/server/src/api/analytics/getSession.ts b/server/src/api/analytics/getSession.ts
index cc88b0716..bb1ef635c 100644
--- a/server/src/api/analytics/getSession.ts
+++ b/server/src/api/analytics/getSession.ts
@@ -54,7 +54,7 @@ export interface SessionPageviewsAndEvents {
export interface GetSessionRequest {
Params: {
sessionId: string;
- site: string;
+ siteId: string;
};
Querystring: {
limit?: string;
@@ -64,7 +64,7 @@ export interface GetSessionRequest {
}
export async function getSession(req: FastifyRequest<GetSessionRequest>, res: FastifyReply) {
- const { sessionId, site } = req.params;
+ const { sessionId, siteId } = req.params;
const limit = req.query.limit ? parseInt(req.query.limit) : 100;
const offset = req.query.offset ? parseInt(req.query.offset) : 0;
const minutes = req.query.minutes ? parseInt(req.query.minutes) : undefined;
@@ -152,7 +152,7 @@ OFFSET {offset:Int32}
query: sessionQuery,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
sessionId,
},
}),
@@ -160,7 +160,7 @@ OFFSET {offset:Int32}
query: countQuery,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
sessionId,
},
}),
@@ -168,7 +168,7 @@ OFFSET {offset:Int32}
query: eventsQuery,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
sessionId,
limit,
offset,
diff --git a/server/src/api/analytics/getSessionLocations.ts b/server/src/api/analytics/getSessionLocations.ts
index e41e970eb..893ec6935 100644
--- a/server/src/api/analytics/getSessionLocations.ts
+++ b/server/src/api/analytics/getSessionLocations.ts
@@ -7,16 +7,16 @@ import { getFilterStatement } from "./utils/getFilterStatement.js";
export async function getSessionLocations(
req: FastifyRequest<{
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{}>;
}>,
res: FastifyReply
) {
- const { site } = req.params;
+ const { siteId } = req.params;
const timeStatement = getTimeStatement(req.query);
- const filterStatement = getFilterStatement(req.query.filters, Number(site), timeStatement);
+ const filterStatement = getFilterStatement(req.query.filters, Number(siteId), timeStatement);
const result = await clickhouse.query({
query: `
@@ -50,7 +50,7 @@ GROUP BY
city,
country`,
query_params: {
- site,
+ site: siteId,
},
format: "JSONEachRow",
});
diff --git a/server/src/api/analytics/getSessions.ts b/server/src/api/analytics/getSessions.ts
index 27f981af5..ec5a68add 100644
--- a/server/src/api/analytics/getSessions.ts
+++ b/server/src/api/analytics/getSessions.ts
@@ -47,7 +47,7 @@ export type GetSessionsResponse = {
export interface GetSessionsRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
limit: number;
@@ -59,7 +59,7 @@ export interface GetSessionsRequest {
export async function getSessions(req: FastifyRequest<GetSessionsRequest>, res: FastifyReply) {
const { filters, page = 1, user_id: userId, limit = 100, identified_only: identifiedOnly = "false" } = req.query;
- const site = req.params.site;
+ const site = req.params.siteId;
const filterIdentified = identifiedOnly === "true";
const timeStatement = getTimeStatement(req.query);
diff --git a/server/src/api/analytics/getUserInfo.ts b/server/src/api/analytics/getUserInfo.ts
index 4e84ef236..e84f336c0 100644
--- a/server/src/api/analytics/getUserInfo.ts
+++ b/server/src/api/analytics/getUserInfo.ts
@@ -43,15 +43,15 @@ export interface UserInfoResponse {
export async function getUserInfo(
req: FastifyRequest<{
Params: {
- site: string;
+ siteId: string;
userId: string;
};
}>,
res: FastifyReply
) {
- const { userId, site } = req.params;
+ const { userId, siteId } = req.params;
- const siteId = Number(site);
+ const numericSiteId = Number(siteId);
try {
// Run ClickHouse query and Postgres queries in parallel
@@ -119,7 +119,7 @@ export async function getUserInfo(
`,
query_params: {
userId,
- site,
+ site: siteId,
},
format: "JSONEachRow",
}),
@@ -127,7 +127,7 @@ export async function getUserInfo(
db
.select()
.from(userProfiles)
- .where(and(eq(userProfiles.siteId, siteId), eq(userProfiles.userId, userId)))
+ .where(and(eq(userProfiles.siteId, numericSiteId), eq(userProfiles.userId, userId)))
.limit(1),
// Get linked devices (all anonymous IDs for this user) from Postgres
db
@@ -136,7 +136,7 @@ export async function getUserInfo(
created_at: userAliases.createdAt,
})
.from(userAliases)
- .where(and(eq(userAliases.siteId, siteId), eq(userAliases.userId, userId))),
+ .where(and(eq(userAliases.siteId, numericSiteId), eq(userAliases.userId, userId))),
]);
const data = await processResults<UserPageviewData>(queryResult);
diff --git a/server/src/api/analytics/getUserSessionCount.ts b/server/src/api/analytics/getUserSessionCount.ts
index b4f993754..62c09f7ae 100644
--- a/server/src/api/analytics/getUserSessionCount.ts
+++ b/server/src/api/analytics/getUserSessionCount.ts
@@ -5,7 +5,7 @@ import SqlString from "sqlstring";
export interface GetUserSessionCountRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: {
user_id?: string;
@@ -19,7 +19,7 @@ export type GetUserSessionCountResponse = {
}[];
export async function getUserSessionCount(req: FastifyRequest<GetUserSessionCountRequest>, res: FastifyReply) {
- const { site } = req.params;
+ const { siteId } = req.params;
const { user_id: userId, time_zone: timeZone = "UTC" } = req.query;
if (!userId) {
@@ -43,7 +43,7 @@ export async function getUserSessionCount(req: FastifyRequest<GetUserSessionCoun
query,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
userId,
},
});
diff --git a/server/src/api/analytics/getUsers.ts b/server/src/api/analytics/getUsers.ts
index 397fedaca..cf5031bbc 100644
--- a/server/src/api/analytics/getUsers.ts
+++ b/server/src/api/analytics/getUsers.ts
@@ -25,7 +25,7 @@ export type GetUsersResponse = {
export interface GetUsersRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
page?: string;
@@ -45,7 +45,7 @@ export async function getUsers(req: FastifyRequest<GetUsersRequest>, res: Fastif
sort_order: sortOrder = "desc",
identified_only: identifiedOnly = "false",
} = req.query;
- const site = req.params.site;
+ const site = req.params.siteId;
const filterIdentified = identifiedOnly === "true";
const pageNum = parseInt(page, 10);
diff --git a/server/src/api/analytics/goals/createGoal.ts b/server/src/api/analytics/goals/createGoal.ts
index 2405783af..a3dedcc27 100644
--- a/server/src/api/analytics/goals/createGoal.ts
+++ b/server/src/api/analytics/goals/createGoal.ts
@@ -61,14 +61,14 @@ type CreateGoalBody = z.infer<typeof goalBodySchema>;
export async function createGoal(
request: FastifyRequest<{
- Params: { site: string };
+ Params: { siteId: string };
Body: CreateGoalBody;
}>,
reply: FastifyReply
) {
try {
// Get siteId from URL params
- const siteId = parseInt(request.params.site, 10);
+ const siteId = parseInt(request.params.siteId, 10);
if (isNaN(siteId) || siteId <= 0) {
return reply.status(400).send({ error: "Invalid site ID" });
}
diff --git a/server/src/api/analytics/goals/getGoalSessions.ts b/server/src/api/analytics/goals/getGoalSessions.ts
index f61f4568d..c5783609c 100644
--- a/server/src/api/analytics/goals/getGoalSessions.ts
+++ b/server/src/api/analytics/goals/getGoalSessions.ts
@@ -10,7 +10,7 @@ import SqlString from "sqlstring";
export interface GetGoalSessionsRequest {
Params: {
- site: string;
+ siteId: string;
goalId: string;
};
Querystring: FilterParams<{
@@ -20,7 +20,7 @@ export interface GetGoalSessionsRequest {
}
export async function getGoalSessions(req: FastifyRequest<GetGoalSessionsRequest>, res: FastifyReply) {
- const { goalId, site } = req.params;
+ const { goalId, siteId } = req.params;
const { page, limit } = req.query;
try {
@@ -38,7 +38,7 @@ export async function getGoalSessions(req: FastifyRequest<GetGoalSessionsRequest
const goalData = goal[0];
// Verify the goal belongs to the site
- if (goalData.siteId !== Number(site)) {
+ if (goalData.siteId !== Number(siteId)) {
return res.status(403).send({ error: "Goal does not belong to this site" });
}
@@ -149,7 +149,7 @@ export async function getGoalSessions(req: FastifyRequest<GetGoalSessionsRequest
query,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
limit: limit || 25,
offset: (page - 1) * (limit || 25),
},
diff --git a/server/src/api/analytics/goals/getGoals.ts b/server/src/api/analytics/goals/getGoals.ts
index b97f12c6c..c5a003280 100644
--- a/server/src/api/analytics/goals/getGoals.ts
+++ b/server/src/api/analytics/goals/getGoals.ts
@@ -33,7 +33,7 @@ interface GetGoalsResponse {
export async function getGoals(
request: FastifyRequest<{
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
page?: string;
@@ -44,7 +44,7 @@ export async function getGoals(
}>,
reply: FastifyReply
) {
- const { site } = request.params;
+ const { siteId } = request.params;
const { filters, page = "1", page_size: pageSize = "10", sort = "createdAt", order = "desc" } = request.query;
const pageNumber = parseInt(page, 10);
@@ -64,7 +64,7 @@ export async function getGoals(
const totalGoalsResult = await db
.select({ count: sql<number>`count(*)` })
.from(goals)
- .where(eq(goals.siteId, Number(site)));
+ .where(eq(goals.siteId, Number(siteId)));
const totalGoals = totalGoalsResult[0]?.count || 0;
const totalPages = Math.ceil(totalGoals / pageSizeNumber);
@@ -104,7 +104,7 @@ export async function getGoals(
const siteGoals = await db
.select()
.from(goals)
- .where(eq(goals.siteId, Number(site)))
+ .where(eq(goals.siteId, Number(siteId)))
.orderBy(orderBy)
.limit(pageSizeNumber)
.offset((pageNumber - 1) * pageSizeNumber);
@@ -124,13 +124,13 @@ export async function getGoals(
// Build filter and time clauses for ClickHouse queries
const timeStatement = getTimeStatement(request.query);
- const filterStatement = filters ? getFilterStatement(filters, Number(site), timeStatement) : "";
+ const filterStatement = filters ? getFilterStatement(filters, Number(siteId), timeStatement) : "";
// First, get the total number of unique sessions (denominator for conversion rate)
const totalSessionsQuery = `
SELECT COUNT(DISTINCT session_id) AS total_sessions
FROM events
- WHERE site_id = ${SqlString.escape(Number(site))}
+ WHERE site_id = ${SqlString.escape(Number(siteId))}
${timeStatement}
${filterStatement}
`;
@@ -223,7 +223,7 @@ export async function getGoals(
SELECT
${conditionalClauses.join(", ")}
FROM events
- WHERE site_id = ${SqlString.escape(Number(site))}
+ WHERE site_id = ${SqlString.escape(Number(siteId))}
${timeStatement}
${filterStatement}
`;
diff --git a/server/src/api/analytics/performance/getPerformanceByDimension.ts b/server/src/api/analytics/performance/getPerformanceByDimension.ts
index 2d31d071d..bb2a47a2c 100644
--- a/server/src/api/analytics/performance/getPerformanceByDimension.ts
+++ b/server/src/api/analytics/performance/getPerformanceByDimension.ts
@@ -6,7 +6,7 @@ import { getFilterStatement } from "../utils/getFilterStatement.js";
interface GetPerformanceByDimensionRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
limit?: number;
@@ -65,7 +65,7 @@ const getQuery = (request: FastifyRequest<GetPerformanceByDimensionRequest>, isC
}
const timeStatement = getTimeStatement(request.query);
- const filterStatement = getFilterStatement(filters, Number(request.params.site), timeStatement);
+ const filterStatement = getFilterStatement(filters, Number(request.params.siteId), timeStatement);
let validatedLimit: number | null = null;
if (!isCountQuery && limit !== undefined) {
@@ -211,7 +211,7 @@ export async function getPerformanceByDimension(
res: FastifyReply
) {
const { page, dimension } = req.query;
- const site = req.params.site;
+ const site = req.params.siteId;
const isPaginatedRequest = page !== undefined;
diff --git a/server/src/api/analytics/performance/getPerformanceOverview.ts b/server/src/api/analytics/performance/getPerformanceOverview.ts
index e7da2f4a0..6375eb47f 100644
--- a/server/src/api/analytics/performance/getPerformanceOverview.ts
+++ b/server/src/api/analytics/performance/getPerformanceOverview.ts
@@ -41,13 +41,13 @@ const getQuery = (params: FilterParams, siteId: number) => {
export interface PerformanceOverviewRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams;
}
export async function getPerformanceOverview(req: FastifyRequest<PerformanceOverviewRequest>, res: FastifyReply) {
- const site = req.params.site;
+ const site = req.params.siteId;
const query = getQuery(req.query, Number(site));
diff --git a/server/src/api/analytics/performance/getPerformanceTimeSeries.ts b/server/src/api/analytics/performance/getPerformanceTimeSeries.ts
index 89f77c8aa..d2ad891e0 100644
--- a/server/src/api/analytics/performance/getPerformanceTimeSeries.ts
+++ b/server/src/api/analytics/performance/getPerformanceTimeSeries.ts
@@ -111,7 +111,7 @@ GROUP BY time ORDER BY time ${isAllTime ? "" : getTimeStatementFill(params, buck
export async function getPerformanceTimeSeries(
req: FastifyRequest<{
Params: {
- site: string;
+ siteId: string;
};
Querystring: FilterParams<{
bucket: TimeBucket;
@@ -119,7 +119,7 @@ export async function getPerformanceTimeSeries(
}>,
res: FastifyReply
) {
- const site = req.params.site;
+ const site = req.params.siteId;
const query = getQuery(req.query, Number(site));
diff --git a/server/src/api/gsc/connect.ts b/server/src/api/gsc/connect.ts
index 75ebed1c1..914663154 100644
--- a/server/src/api/gsc/connect.ts
+++ b/server/src/api/gsc/connect.ts
@@ -9,15 +9,15 @@ import { logger } from "../../lib/logger/logger.js";
*/
export async function connectGSC(req: FastifyRequest<ConnectGSCRequest>, res: FastifyReply) {
try {
- const { site } = req.params;
- const siteId = Number(site);
+ const { siteId } = req.params;
+ const numericSiteId = Number(siteId);
- if (isNaN(siteId)) {
+ if (isNaN(numericSiteId)) {
return res.status(400).send({ error: "Invalid site ID" });
}
// Check if user has access to this site
- const hasAccess = await getUserHasAccessToSite(req, siteId);
+ const hasAccess = await getUserHasAccessToSite(req, numericSiteId);
if (!hasAccess) {
return res.status(403).send({ error: "Access denied" });
}
@@ -31,7 +31,7 @@ export async function connectGSC(req: FastifyRequest<ConnectGSCRequest>, res: Fa
// Build OAuth URL
const scope = "https://www.googleapis.com/auth/webmasters.readonly";
- const state = siteId.toString(); // Pass siteId in state to retrieve after OAuth
+ const state = numericSiteId.toString(); // Pass siteId in state to retrieve after OAuth
const authUrl = new URL("https://accounts.google.com/o/oauth2/v2/auth");
authUrl.searchParams.set("client_id", clientId);
diff --git a/server/src/api/gsc/disconnect.ts b/server/src/api/gsc/disconnect.ts
index 4201955fb..e7a6bf40f 100644
--- a/server/src/api/gsc/disconnect.ts
+++ b/server/src/api/gsc/disconnect.ts
@@ -12,21 +12,21 @@ import { logger } from "../../lib/logger/logger.js";
*/
export async function disconnectGSC(req: FastifyRequest<DisconnectGSCRequest>, res: FastifyReply) {
try {
- const { site } = req.params;
- const siteId = Number(site);
+ const { siteId } = req.params;
+ const numericSiteId = Number(siteId);
- if (isNaN(siteId)) {
+ if (isNaN(numericSiteId)) {
return res.status(400).send({ error: "Invalid site ID" });
}
// Check if user has access to this site
- const hasAccess = await getUserHasAccessToSite(req, siteId);
+ const hasAccess = await getUserHasAccessToSite(req, numericSiteId);
if (!hasAccess) {
return res.status(403).send({ error: "Access denied" });
}
// Delete the connection
- await db.delete(gscConnections).where(eq(gscConnections.siteId, siteId));
+ await db.delete(gscConnections).where(eq(gscConnections.siteId, numericSiteId));
return res.send({ success: true });
} catch (error) {
diff --git a/server/src/api/gsc/getData.ts b/server/src/api/gsc/getData.ts
index cb50c5027..e9b3a89a2 100644
--- a/server/src/api/gsc/getData.ts
+++ b/server/src/api/gsc/getData.ts
@@ -13,11 +13,11 @@ import { logger } from "../../lib/logger/logger.js";
*/
export async function getGSCData(req: FastifyRequest<GetGSCDataRequest>, res: FastifyReply) {
try {
- const { site } = req.params;
+ const { siteId } = req.params;
const { start_date, end_date, dimension } = req.query;
- const siteId = Number(site);
+ const numericSiteId = Number(siteId);
- if (isNaN(siteId)) {
+ if (isNaN(numericSiteId)) {
return res.status(400).send({ error: "Invalid site ID" });
}
@@ -30,14 +30,14 @@ export async function getGSCData(req: FastifyRequest<GetGSCDataRequest>, res: Fa
}
// Get connection
- const [connection] = await db.select().from(gscConnections).where(eq(gscConnections.siteId, siteId));
+ const [connection] = await db.select().from(gscConnections).where(eq(gscConnections.siteId, numericSiteId));
if (!connection) {
return res.status(404).send({ error: "GSC not connected for this site" });
}
// Refresh token if needed
- const accessToken = await refreshGSCToken(siteId);
+ const accessToken = await refreshGSCToken(numericSiteId);
if (!accessToken) {
return res.status(500).send({ error: "Failed to refresh access token" });
}
diff --git a/server/src/api/gsc/selectProperty.ts b/server/src/api/gsc/selectProperty.ts
index 8de08b00b..47beb5a1d 100644
--- a/server/src/api/gsc/selectProperty.ts
+++ b/server/src/api/gsc/selectProperty.ts
@@ -7,7 +7,7 @@ import { logger } from "../../lib/logger/logger.js";
interface SelectPropertyRequest {
Params: {
- site: string;
+ siteId: string;
};
Body: {
propertyUrl: string;
@@ -19,11 +19,11 @@ interface SelectPropertyRequest {
*/
export async function selectGSCProperty(req: FastifyRequest<SelectPropertyRequest>, res: FastifyReply) {
try {
- const { site } = req.params;
+ const { siteId } = req.params;
const { propertyUrl } = req.body;
- const siteId = Number(site);
+ const numericSiteId = Number(siteId);
- if (isNaN(siteId)) {
+ if (isNaN(numericSiteId)) {
return res.status(400).send({ error: "Invalid site ID" });
}
@@ -32,7 +32,7 @@ export async function selectGSCProperty(req: FastifyRequest<SelectPropertyReques
}
// Check if user has access to this site
- const hasAccess = await getUserHasAccessToSite(req, siteId);
+ const hasAccess = await getUserHasAccessToSite(req, numericSiteId);
if (!hasAccess) {
return res.status(403).send({ error: "Access denied" });
}
@@ -44,7 +44,7 @@ export async function selectGSCProperty(req: FastifyRequest<SelectPropertyReques
gscPropertyUrl: propertyUrl,
updatedAt: new Date().toISOString(),
})
- .where(eq(gscConnections.siteId, siteId))
+ .where(eq(gscConnections.siteId, numericSiteId))
.returning();
if (result.length === 0) {
diff --git a/server/src/api/gsc/status.ts b/server/src/api/gsc/status.ts
index b3745a226..b913e6bbb 100644
--- a/server/src/api/gsc/status.ts
+++ b/server/src/api/gsc/status.ts
@@ -10,14 +10,14 @@ import { GetGSCStatusRequest } from "./types.js";
*/
export async function getGSCStatus(req: FastifyRequest<GetGSCStatusRequest>, res: FastifyReply) {
try {
- const { site } = req.params;
- const siteId = Number(site);
+ const { siteId } = req.params;
+ const numericSiteId = Number(siteId);
- if (isNaN(siteId)) {
+ if (isNaN(numericSiteId)) {
return res.status(400).send({ error: "Invalid site ID" });
}
- const [connection] = await db.select().from(gscConnections).where(eq(gscConnections.siteId, siteId));
+ const [connection] = await db.select().from(gscConnections).where(eq(gscConnections.siteId, numericSiteId));
if (!connection) {
return res.send({
diff --git a/server/src/api/gsc/types.ts b/server/src/api/gsc/types.ts
index 1d6e31b7e..1bf2d42e0 100644
--- a/server/src/api/gsc/types.ts
+++ b/server/src/api/gsc/types.ts
@@ -14,7 +14,7 @@ export interface GSCResponse {
export interface GetGSCDataRequest {
Params: {
- site: string;
+ siteId: string;
};
Querystring: {
start_date: string;
@@ -25,7 +25,7 @@ export interface GetGSCDataRequest {
export interface ConnectGSCRequest {
Params: {
- site: string;
+ siteId: string;
};
}
@@ -39,12 +39,12 @@ export interface GSCCallbackRequest {
export interface DisconnectGSCRequest {
Params: {
- site: string;
+ siteId: string;
};
}
export interface GetGSCStatusRequest {
Params: {
- site: string;
+ siteId: string;
};
}
diff --git a/server/src/api/sessionReplay/deleteSessionReplay.ts b/server/src/api/sessionReplay/deleteSessionReplay.ts
index 53bb88ea7..e6fbec381 100644
--- a/server/src/api/sessionReplay/deleteSessionReplay.ts
+++ b/server/src/api/sessionReplay/deleteSessionReplay.ts
@@ -1,41 +1,32 @@
import { FastifyReply, FastifyRequest } from "fastify";
-import { getUserHasAccessToSite } from "../../lib/auth-utils.js";
import { SessionReplayQueryService } from "../../services/replay/sessionReplayQueryService.js";
export async function deleteSessionReplay(
request: FastifyRequest<{
Params: {
sessionId: string;
- site: string;
+ siteId: string;
};
}>,
reply: FastifyReply
) {
- const { sessionId, site } = request.params;
+ const { sessionId, siteId } = request.params;
try {
- // Parse site ID
- const siteId = parseInt(site);
- if (isNaN(siteId)) {
+ const numericSiteId = parseInt(siteId);
+ if (isNaN(numericSiteId)) {
return reply.status(400).send({ error: "Invalid site ID" });
}
- // Check user access to site
- const userHasAccessToSite = await getUserHasAccessToSite(request, site);
- if (!userHasAccessToSite) {
- return reply.status(403).send({ error: "Forbidden" });
- }
-
- // Check if session replay exists
const sessionReplayQueryService = new SessionReplayQueryService();
- const metadata = await sessionReplayQueryService.getSessionReplayMetadata(siteId, sessionId);
+ const metadata = await sessionReplayQueryService.getSessionReplayMetadata(numericSiteId, sessionId);
if (!metadata) {
return reply.status(404).send({ error: "Session replay not found" });
}
// Delete the session replay
- await sessionReplayQueryService.deleteSessionReplay(siteId, sessionId);
+ await sessionReplayQueryService.deleteSessionReplay(numericSiteId, sessionId);
return reply.status(200).send({ success: true });
} catch (error) {
diff --git a/server/src/api/sessionReplay/getSessionReplayEvents.ts b/server/src/api/sessionReplay/getSessionReplayEvents.ts
index bc4e989aa..2c8fef438 100644
--- a/server/src/api/sessionReplay/getSessionReplayEvents.ts
+++ b/server/src/api/sessionReplay/getSessionReplayEvents.ts
@@ -4,12 +4,12 @@ import { enrichWithTraits } from "../analytics/utils/utils.js";
export async function getSessionReplayEvents(
request: FastifyRequest<{
- Params: { site: string; sessionId: string };
+ Params: { siteId: string; sessionId: string };
}>,
reply: FastifyReply
) {
try {
- const siteId = Number(request.params.site);
+ const siteId = Number(request.params.siteId);
const { sessionId } = request.params;
const sessionReplayService = new SessionReplayQueryService();
diff --git a/server/src/api/sessionReplay/getSessionReplays.ts b/server/src/api/sessionReplay/getSessionReplays.ts
index 76be96ec2..2a2f575d8 100644
--- a/server/src/api/sessionReplay/getSessionReplays.ts
+++ b/server/src/api/sessionReplay/getSessionReplays.ts
@@ -5,7 +5,7 @@ import { enrichWithTraits } from "../analytics/utils/utils.js";
export async function getSessionReplays(
request: FastifyRequest<{
- Params: { site: string };
+ Params: { siteId: string };
Querystring: FilterParams<{
limit?: string;
offset?: string;
@@ -16,7 +16,7 @@ export async function getSessionReplays(
reply: FastifyReply
) {
try {
- const siteId = Number(request.params.site);
+ const siteId = Number(request.params.siteId);
const { limit, offset, userId, minDuration, filters } = request.query;
const sessionReplayService = new SessionReplayQueryService();
diff --git a/server/src/api/sessionReplay/recordSessionReplay.ts b/server/src/api/sessionReplay/recordSessionReplay.ts
index 3159f8b03..37061e0f4 100644
--- a/server/src/api/sessionReplay/recordSessionReplay.ts
+++ b/server/src/api/sessionReplay/recordSessionReplay.ts
@@ -28,14 +28,14 @@ const recordSessionReplaySchema = z.object({
export async function recordSessionReplay(
request: FastifyRequest<{
- Params: { site: string };
+ Params: { siteId: string };
Body: RecordSessionReplayRequest;
}>,
reply: FastifyReply
) {
try {
// Get the site configuration to get the numeric siteId
- const { siteId, excludedIPs, excludedCountries, sessionReplay } = (await siteConfig.getConfig(request.params.site)) ?? {};
+ const { siteId, excludedIPs, excludedCountries, sessionReplay } = (await siteConfig.getConfig(request.params.siteId)) ?? {};
if (!sessionReplay) {
logger.info(`[SessionReplay] Skipping event for site ${siteId} - session replay not enabled`);
@@ -43,7 +43,7 @@ export async function recordSessionReplay(
}
if (!siteId) {
- throw new Error(`Site not found: ${request.params.site}`);
+ throw new Error(`Site not found: ${request.params.siteId}`);
}
// Check if the site has exceeded its monthly limit
@@ -72,7 +72,7 @@ export async function recordSessionReplay(
const locationData = locationResults[requestIP];
if (locationData?.countryIso) {
- const isCountryExcluded = await siteConfig.isCountryExcluded(locationData.countryIso, request.params.site);
+ const isCountryExcluded = await siteConfig.isCountryExcluded(locationData.countryIso, request.params.siteId);
if (isCountryExcluded) {
logger.info(`[SessionReplay] Country ${locationData.countryIso} excluded from tracking for site ${siteId}`);
return reply.status(200).send({
diff --git a/server/src/api/sites/addSite.ts b/server/src/api/sites/addSite.ts
index 3f1e93035..7c103683e 100644
--- a/server/src/api/sites/addSite.ts
+++ b/server/src/api/sites/addSite.ts
@@ -2,14 +2,15 @@ import { randomBytes } from "crypto";
import { FastifyReply, FastifyRequest } from "fastify";
import { db } from "../../db/postgres/postgres.js";
import { sites } from "../../db/postgres/schema.js";
-import { getSessionFromReq } from "../../lib/auth-utils.js";
export async function addSite(
request: FastifyRequest<{
+ Params: {
+ orgId: string;
+ };
Body: {
domain: string;
name: string;
- organizationId: string;
public?: boolean;
saltUserIds?: boolean;
blockBots?: boolean;
@@ -17,7 +18,8 @@ export async function addSite(
}>,
reply: FastifyReply
) {
- const { domain, name, organizationId, public: isPublic, saltUserIds, blockBots } = request.body;
+ const { orgId: organizationId } = request.params;
+ const { domain, name, public: isPublic, saltUserIds, blockBots } = request.body;
// Validate domain format using regex
const domainRegex = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
@@ -28,41 +30,8 @@ export async function addSite(
}
try {
- const session = await getSessionFromReq(request);
-
- if (!session?.user?.id) {
- return reply.status(401).send({
- error: "Unauthorized",
- message: "You must be logged in to add a site",
- });
- }
-
- // Check if the organization exists
- if (!organizationId) {
- return reply.status(400).send({
- error: "Organization ID is required",
- });
- }
-
- // Check if the user is an owner or admin of the organization
- // First, get the user's role in the organization
- const member = await db.query.member.findFirst({
- where: (member, { and, eq }) =>
- and(eq(member.userId, session.user.id), eq(member.organizationId, organizationId)),
- });
-
- if (!member) {
- return reply.status(403).send({
- error: "You are not a member of this organization",
- });
- }
-
- // Check if the user's role is admin or owner
- if (member.role !== "admin" && member.role !== "owner") {
- return reply.status(403).send({
- error: "You must be an admin or owner to add sites to this organization",
- });
- }
+ // Auth and org admin check handled by requireOrgAdminFromBody middleware
+ const userId = request.user?.id;
// Generate a random 12-character hex ID
const id = randomBytes(6).toString("hex");
@@ -74,7 +43,7 @@ export async function addSite(
id,
domain,
name,
- createdBy: session.user.id,
+ createdBy: userId,
organizationId,
public: isPublic || false,
saltUserIds: saltUserIds || false,
diff --git a/server/src/api/sites/batchImportEvents.ts b/server/src/api/sites/batchImportEvents.ts
index 132bdd7e7..186b02f31 100644
--- a/server/src/api/sites/batchImportEvents.ts
+++ b/server/src/api/sites/batchImportEvents.ts
@@ -1,6 +1,5 @@
import { FastifyReply, FastifyRequest } from "fastify";
import { z } from "zod";
-import { getUserHasAdminAccessToSite } from "../../lib/auth-utils.js";
import { clickhouse } from "../../db/clickhouse/clickhouse.js";
import { updateImportProgress, completeImport, getImportById } from "../../services/import/importStatusManager.js";
import { UmamiEvent, UmamiImportMapper } from "../../services/import/mappings/umami.js";
@@ -15,7 +14,7 @@ import { IS_CLOUD } from "../../lib/const.js";
const batchImportRequestSchema = z
.object({
params: z.object({
- site: z.coerce.number().int().positive(),
+ siteId: z.coerce.number().int().positive(),
importId: z.string().uuid(),
}),
body: z.object({
@@ -44,20 +43,15 @@ export async function batchImportEvents(request: FastifyRequest<BatchImportReque
return reply.status(400).send({ error: "Validation error" });
}
- const { site, importId } = parsed.data.params;
+ const { siteId, importId } = parsed.data.params;
const { events, isLastBatch } = parsed.data.body;
- const userHasAccess = await getUserHasAdminAccessToSite(request, site);
- if (!userHasAccess) {
- return reply.status(403).send({ error: "Forbidden" });
- }
-
const importRecord = await getImportById(importId);
if (!importRecord) {
return reply.status(404).send({ error: "Import not found" });
}
- if (importRecord.siteId !== site) {
+ if (importRecord.siteId !== siteId) {
return reply.status(400).send({ error: "Import does not belong to this site" });
}
@@ -68,7 +62,7 @@ export async function batchImportEvents(request: FastifyRequest<BatchImportReque
})
.from(sites)
.leftJoin(organization, eq(sites.organizationId, organization.id))
- .where(eq(sites.siteId, site))
+ .where(eq(sites.siteId, siteId))
.limit(1);
if (!siteRecord || !siteRecord.organizationId) {
@@ -90,9 +84,9 @@ export async function batchImportEvents(request: FastifyRequest<BatchImportReque
let transformedEvents;
if (importRecord.platform === "umami") {
- transformedEvents = UmamiImportMapper.transform(events as UmamiEvent[], site, importId);
+ transformedEvents = UmamiImportMapper.transform(events as UmamiEvent[], siteId, importId);
} else if (importRecord.platform === "simple_analytics") {
- transformedEvents = SimpleAnalyticsImportMapper.transform(events as SimpleAnalyticsEvent[], site, importId);
+ transformedEvents = SimpleAnalyticsImportMapper.transform(events as SimpleAnalyticsEvent[], siteId, importId);
} else {
return reply.status(400).send({ error: "Unsupported platform" });
}
diff --git a/server/src/api/sites/createSiteImport.ts b/server/src/api/sites/createSiteImport.ts
index c93befca5..56c26925f 100644
--- a/server/src/api/sites/createSiteImport.ts
+++ b/server/src/api/sites/createSiteImport.ts
@@ -1,5 +1,4 @@
import { FastifyReply, FastifyRequest } from "fastify";
-import { getUserHasAdminAccessToSite } from "../../lib/auth-utils.js";
import { importQuotaManager } from "../../services/import/importQuotaManager.js";
import { createImport } from "../../services/import/importStatusManager.js";
import { DateTime } from "luxon";
@@ -13,7 +12,7 @@ import { IS_CLOUD } from "../../lib/const.js";
const createSiteImportRequestSchema = z
.object({
params: z.object({
- site: z.coerce.number().int().positive(),
+ siteId: z.coerce.number().int().positive(),
}),
body: z.object({
platform: z.enum(importPlatforms),
@@ -37,14 +36,9 @@ export async function createSiteImport(request: FastifyRequest<CreateSiteImportR
return reply.status(400).send({ error: "Validation error" });
}
- const { site } = parsed.data.params;
+ const { siteId } = parsed.data.params;
const { platform } = parsed.data.body;
- const userHasAccess = await getUserHasAdminAccessToSite(request, site);
- if (!userHasAccess) {
- return reply.status(403).send({ error: "Forbidden" });
- }
-
const [siteRecord] = await db
.select({
organizationId: sites.organizationId,
@@ -52,7 +46,7 @@ export async function createSiteImport(request: FastifyRequest<CreateSiteImportR
})
.from(sites)
.leftJoin(organization, eq(sites.organizationId, organization.id))
- .where(eq(sites.siteId, site))
+ .where(eq(sites.siteId, siteId))
.limit(1);
if (!siteRecord || !siteRecord.organizationId) {
@@ -85,7 +79,7 @@ export async function createSiteImport(request: FastifyRequest<CreateSiteImportR
const latestAllowedDate = DateTime.utc().toFormat("yyyy-MM-dd");
const importRecord = await createImport({
- siteId: site,
+ siteId,
organizationId,
platform,
});
diff --git a/server/src/api/sites/deleteSite.ts b/server/src/api/sites/deleteSite.ts
index 874595d44..ad4f69925 100644
--- a/server/src/api/sites/deleteSite.ts
+++ b/server/src/api/sites/deleteSite.ts
@@ -1,18 +1,13 @@
import { FastifyReply, FastifyRequest } from "fastify";
import { eq } from "drizzle-orm";
-import { clickhouse } from "../../db/clickhouse/clickhouse.js";
import { db } from "../../db/postgres/postgres.js";
import { sites } from "../../db/postgres/schema.js";
-import { getUserHasAdminAccessToSite } from "../../lib/auth-utils.js";
import { siteConfig } from "../../lib/siteConfig.js";
-export async function deleteSite(request: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) {
- const { id } = request.params;
+export async function deleteSite(request: FastifyRequest<{ Params: { siteId: string } }>, reply: FastifyReply) {
+ const { siteId: id } = request.params;
- const userHasAdminAccessToSite = await getUserHasAdminAccessToSite(request, id);
- if (!userHasAdminAccessToSite) {
- return reply.status(403).send({ error: "Forbidden" });
- }
+ // Auth is handled by requireSiteAdminAccess middleware
// await clickhouse.command({
// query: "DELETE FROM events WHERE site_id = {id:UInt32}",
diff --git a/server/src/api/sites/deleteSiteImport.ts b/server/src/api/sites/deleteSiteImport.ts
index 224cbe0db..161c93e9b 100644
--- a/server/src/api/sites/deleteSiteImport.ts
+++ b/server/src/api/sites/deleteSiteImport.ts
@@ -1,6 +1,5 @@
import { FastifyReply, FastifyRequest } from "fastify";
import { z } from "zod";
-import { getUserHasAdminAccessToSite } from "../../lib/auth-utils.js";
import { getImportById, deleteImport } from "../../services/import/importStatusManager.js";
import { clickhouse } from "../../db/clickhouse/clickhouse.js";
import { importQuotaManager } from "../../services/import/importQuotaManager.js";
@@ -13,7 +12,7 @@ import { IS_CLOUD } from "../../lib/const.js";
const deleteImportRequestSchema = z
.object({
params: z.object({
- site: z.coerce.number().int().positive(),
+ siteId: z.coerce.number().int().positive(),
importId: z.string().uuid(),
}),
})
@@ -33,19 +32,14 @@ export async function deleteSiteImport(request: FastifyRequest<DeleteImportReque
return reply.status(400).send({ error: "Validation error" });
}
- const { site, importId } = parsed.data.params;
-
- const userHasAccess = await getUserHasAdminAccessToSite(request, site);
- if (!userHasAccess) {
- return reply.status(403).send({ error: "Forbidden" });
- }
+ const { siteId, importId } = parsed.data.params;
const importRecord = await getImportById(importId);
if (!importRecord) {
return reply.status(404).send({ error: "Import not found" });
}
- if (importRecord.siteId !== site) {
+ if (importRecord.siteId !== siteId) {
return reply.status(403).send({ error: "Import does not belong to this site" });
}
@@ -61,7 +55,7 @@ export async function deleteSiteImport(request: FastifyRequest<DeleteImportReque
})
.from(sites)
.leftJoin(organization, eq(sites.organizationId, organization.id))
- .where(eq(sites.siteId, site))
+ .where(eq(sites.siteId, siteId))
.limit(1);
if (siteRecord.organizationId) {
@@ -80,7 +74,7 @@ export async function deleteSiteImport(request: FastifyRequest<DeleteImportReque
query: "DELETE FROM events WHERE import_id = {importId:UUID} AND site_id = {siteId:UInt16}",
query_params: {
importId: importId,
- siteId: site,
+ siteId: siteId,
},
});
} catch (chError) {
diff --git a/server/src/api/sites/getSite.ts b/server/src/api/sites/getSite.ts
index a09aea31b..323741a8f 100644
--- a/server/src/api/sites/getSite.ts
+++ b/server/src/api/sites/getSite.ts
@@ -6,17 +6,17 @@ import { getUserHasAdminAccessToSite } from "../../lib/auth-utils.js";
interface GetSiteParams {
Params: {
- id: string;
+ siteId: string;
};
}
export async function getSite(request: FastifyRequest<GetSiteParams>, reply: FastifyReply) {
- const { id } = request.params;
+ const { siteId } = request.params;
try {
// Get site info
const site = await db.query.sites.findFirst({
- where: eq(sites.siteId, Number(id)),
+ where: eq(sites.siteId, Number(siteId)),
});
if (!site) {
diff --git a/server/src/api/sites/getSiteExcludedCountries.ts b/server/src/api/sites/getSiteExcludedCountries.ts
index 9d1c6e2cd..4a42692c5 100644
--- a/server/src/api/sites/getSiteExcludedCountries.ts
+++ b/server/src/api/sites/getSiteExcludedCountries.ts
@@ -3,7 +3,6 @@ import { z } from "zod";
import { db } from "../../db/postgres/postgres.js";
import { sites } from "../../db/postgres/schema.js";
import { eq } from "drizzle-orm";
-import { getUserHasAccessToSite } from "../../lib/auth-utils.js";
const getSiteExcludedCountriesSchema = z.object({
siteId: z.string().min(1),
@@ -24,23 +23,6 @@ export async function getSiteExcludedCountries(request: FastifyRequest, reply: F
const { siteId } = validationResult.data;
const numericSiteId = Number(siteId);
- if (!Number.isInteger(numericSiteId) || isNaN(numericSiteId) || numericSiteId <= 0) {
- return reply.status(400).send({
- success: false,
- error: "Invalid site ID: must be a positive integer",
- });
- }
-
- // Check if user has access to this site
- const hasAccess = await getUserHasAccessToSite(request, numericSiteId);
-
- if (!hasAccess) {
- return reply.status(403).send({
- success: false,
- error: "Forbidden: You don't have access to this site",
- });
- }
-
const site = await db
.select({
excludedCountries: sites.excludedCountries,
diff --git a/server/src/api/sites/getSiteExcludedIPs.ts b/server/src/api/sites/getSiteExcludedIPs.ts
index d7aa63d91..8284762fb 100644
--- a/server/src/api/sites/getSiteExcludedIPs.ts
+++ b/server/src/api/sites/getSiteExcludedIPs.ts
@@ -3,7 +3,6 @@ import { z } from "zod";
import { db } from "../../db/postgres/postgres.js";
import { sites } from "../../db/postgres/schema.js";
import { eq } from "drizzle-orm";
-import { getUserHasAccessToSite } from "../../lib/auth-utils.js";
const getSiteExcludedIPsSchema = z.object({
siteId: z.string().min(1),
@@ -32,16 +31,6 @@ export async function getSiteExcludedIPs(request: FastifyRequest, reply: Fastify
});
}
- // Check if user has access to this site
- const hasAccess = await getUserHasAccessToSite(request, numericSiteId);
-
- if (!hasAccess) {
- return reply.status(403).send({
- success: false,
- error: "Forbidden: You don't have access to this site",
- });
- }
-
// Get the excluded IPs from the database
const site = await db
.select({
diff --git a/server/src/api/sites/getSiteHasData.ts b/server/src/api/sites/getSiteHasData.ts
index 9b9393538..8926d4d2f 100644
--- a/server/src/api/sites/getSiteHasData.ts
+++ b/server/src/api/sites/getSiteHasData.ts
@@ -1,8 +1,8 @@
import { FastifyReply, FastifyRequest } from "fastify";
import { clickhouse } from "../../db/clickhouse/clickhouse.js";
-export async function getSiteHasData(request: FastifyRequest<{ Params: { site: string } }>, reply: FastifyReply) {
- const { site } = request.params;
+export async function getSiteHasData(request: FastifyRequest<{ Params: { siteId: string } }>, reply: FastifyReply) {
+ const { siteId } = request.params;
try {
// Check if site has data using original method
@@ -11,7 +11,7 @@ export async function getSiteHasData(request: FastifyRequest<{ Params: { site: s
query: `SELECT count(*) as count FROM events WHERE site_id = {siteId:Int32}`,
format: "JSONEachRow",
query_params: {
- siteId: Number(site),
+ siteId: Number(siteId),
},
})
.then(res => res.json());
diff --git a/server/src/api/sites/getSiteImports.ts b/server/src/api/sites/getSiteImports.ts
index 5ba3085ec..74e6f7ba0 100644
--- a/server/src/api/sites/getSiteImports.ts
+++ b/server/src/api/sites/getSiteImports.ts
@@ -1,5 +1,4 @@
import { FastifyReply, FastifyRequest } from "fastify";
-import { getUserHasAdminAccessToSite } from "../../lib/auth-utils.js";
import { getImportsForSite } from "../../services/import/importStatusManager.js";
import { z } from "zod";
import { db } from "../../db/postgres/postgres.js";
@@ -11,7 +10,7 @@ import { IS_CLOUD } from "../../lib/const.js";
const getSiteImportsRequestSchema = z
.object({
params: z.object({
- site: z.coerce.number().int().positive(),
+ siteId: z.coerce.number().int().positive(),
}),
})
.strict();
@@ -30,12 +29,7 @@ export async function getSiteImports(request: FastifyRequest<GetSiteImportsReque
return reply.status(400).send({ error: "Validation error" });
}
- const { site } = parsed.data.params;
-
- const userHasAccess = await getUserHasAdminAccessToSite(request, site);
- if (!userHasAccess) {
- return reply.status(403).send({ error: "Forbidden" });
- }
+ const { siteId } = parsed.data.params;
if (IS_CLOUD) {
const [siteRecord] = await db
@@ -45,7 +39,7 @@ export async function getSiteImports(request: FastifyRequest<GetSiteImportsReque
})
.from(sites)
.leftJoin(organization, eq(sites.organizationId, organization.id))
- .where(eq(sites.siteId, site))
+ .where(eq(sites.siteId, siteId))
.limit(1);
if (siteRecord.organizationId) {
@@ -59,7 +53,7 @@ export async function getSiteImports(request: FastifyRequest<GetSiteImportsReque
}
}
- const imports = await getImportsForSite(site);
+ const imports = await getImportsForSite(siteId);
return reply.send({
data: imports.map(
diff --git a/server/src/api/sites/getSiteIsPublic.ts b/server/src/api/sites/getSiteIsPublic.ts
index 07a1fe5a9..0c1cb6abc 100644
--- a/server/src/api/sites/getSiteIsPublic.ts
+++ b/server/src/api/sites/getSiteIsPublic.ts
@@ -1,9 +1,9 @@
import { FastifyRequest, FastifyReply } from "fastify";
import { siteConfig } from "../../lib/siteConfig.js";
-export async function getSiteIsPublic(request: FastifyRequest<{ Params: { site: string } }>, reply: FastifyReply) {
- const { site } = request.params;
- const config = await siteConfig.getConfig(site);
+export async function getSiteIsPublic(request: FastifyRequest<{ Params: { siteId: string } }>, reply: FastifyReply) {
+ const { siteId } = request.params;
+ const config = await siteConfig.getConfig(siteId);
const isPublic = config?.public || false;
return reply.status(200).send({ isPublic });
}
diff --git a/server/src/api/sites/getSitePrivateLinkConfig.ts b/server/src/api/sites/getSitePrivateLinkConfig.ts
index 18cd4b3e0..5e58a963e 100644
--- a/server/src/api/sites/getSitePrivateLinkConfig.ts
+++ b/server/src/api/sites/getSitePrivateLinkConfig.ts
@@ -1,18 +1,13 @@
import { FastifyRequest, FastifyReply } from "fastify";
import { db } from "../../db/postgres/postgres.js";
import { sites } from "../../db/postgres/schema.js";
-import { eq, and } from "drizzle-orm";
-import { getUserHasAdminAccessToSite } from "../../lib/auth-utils.js";
+import { eq } from "drizzle-orm";
export async function getSitePrivateLinkConfig(
request: FastifyRequest<{ Params: { siteId: string } }>,
reply: FastifyReply
) {
try {
- if (!request.user) {
- return reply.status(401).send({ success: false, error: "Unauthorized" });
- }
-
const { siteId } = request.params;
const parsedSiteId = parseInt(siteId, 10);
@@ -20,11 +15,6 @@ export async function getSitePrivateLinkConfig(
return reply.status(400).send({ success: false, error: "Invalid site ID" });
}
- const userHasAdminAccessToSite = await getUserHasAdminAccessToSite(request, String(parsedSiteId));
- if (!userHasAdminAccessToSite) {
- return reply.status(403).send({ error: "Forbidden" });
- }
-
// Get site data
const site = await db
.select({
diff --git a/server/src/api/sites/getSitesFromOrg.ts b/server/src/api/sites/getSitesFromOrg.ts
index 3f61caa45..bae3ca3ff 100644
--- a/server/src/api/sites/getSitesFromOrg.ts
+++ b/server/src/api/sites/getSitesFromOrg.ts
@@ -3,7 +3,6 @@ import { FastifyRequest, FastifyReply } from "fastify";
import { clickhouse } from "../../db/clickhouse/clickhouse.js";
import { db } from "../../db/postgres/postgres.js";
import { sites, member, organization } from "../../db/postgres/schema.js";
-import { getSessionFromReq, getIsUserAdmin } from "../../lib/auth-utils.js";
import { IS_CLOUD, DEFAULT_EVENT_LIMIT } from "../../lib/const.js";
import { processResults } from "../analytics/utils/utils.js";
import { getSubscriptionInner } from "../stripe/getSubscription.js";
@@ -18,30 +17,22 @@ export async function getSitesFromOrg(
) {
try {
const { organizationId } = req.params;
- const session = await getSessionFromReq(req);
- const userId = session?.user.id;
- if (!userId) {
- return res.status(401).send({ error: "Unauthorized" });
- }
+ const userId = req.user?.id;
// Run all database queries concurrently
- const [isOwner, memberCheck, sitesData, orgInfo] = await Promise.all([
- getIsUserAdmin(req),
- db
- .select()
- .from(member)
- .where(and(eq(member.organizationId, organizationId), eq(member.userId, userId)))
- .limit(1),
+ const [memberCheck, sitesData, orgInfo] = await Promise.all([
+ userId
+ ? db
+ .select()
+ .from(member)
+ .where(and(eq(member.organizationId, organizationId), eq(member.userId, userId)))
+ .limit(1)
+ : Promise.resolve([]),
db.select().from(sites).where(eq(sites.organizationId, organizationId)),
db.select().from(organization).where(eq(organization.id, organizationId)).limit(1),
]);
- // If not admin, verify user is a member of the organization
- if (!isOwner && memberCheck.length === 0) {
- return res.status(403).send({ error: "Access denied to this organization" });
- }
-
// Query session counts for the sites
const sessionCountMap = new Map<number, number>();
diff --git a/server/src/api/sites/updateSiteConfig.ts b/server/src/api/sites/updateSiteConfig.ts
index 1cc393e94..1061d21ff 100644
--- a/server/src/api/sites/updateSiteConfig.ts
+++ b/server/src/api/sites/updateSiteConfig.ts
@@ -3,7 +3,6 @@ import { z } from "zod";
import { db } from "../../db/postgres/postgres.js";
import { sites } from "../../db/postgres/schema.js";
import { eq } from "drizzle-orm";
-import { getUserHasAdminAccessToSite } from "../../lib/auth-utils.js";
import { siteConfig } from "../../lib/siteConfig.js";
import { validateIPPattern } from "../../lib/ipUtils.js";
@@ -46,12 +45,12 @@ const updateSiteConfigSchema = z.object({
type UpdateSiteConfigRequest = z.infer<typeof updateSiteConfigSchema>;
export async function updateSiteConfig(
- request: FastifyRequest<{ Params: { id: string }; Body: UpdateSiteConfigRequest }>,
+ request: FastifyRequest<{ Params: { siteId: string }; Body: UpdateSiteConfigRequest }>,
reply: FastifyReply
) {
try {
// Get siteId from path params
- const siteId = parseInt(request.params.id, 10);
+ const siteId = parseInt(request.params.siteId, 10);
if (isNaN(siteId) || siteId <= 0) {
return reply.status(400).send({
success: false,
@@ -71,12 +70,6 @@ export async function updateSiteConfig(
const updateData = validationResult.data;
- // Check user permissions
- const userHasAdminAccessToSite = await getUserHasAdminAccessToSite(request, String(siteId));
- if (!userHasAdminAccessToSite) {
- return reply.status(403).send({ error: "Forbidden" });
- }
-
// Check if site exists
const site = await db.query.sites.findFirst({
where: eq(sites.siteId, siteId),
diff --git a/server/src/api/sites/updateSitePrivateLinkConfig.ts b/server/src/api/sites/updateSitePrivateLinkConfig.ts
index 67c268463..09b31ee13 100644
--- a/server/src/api/sites/updateSitePrivateLinkConfig.ts
+++ b/server/src/api/sites/updateSitePrivateLinkConfig.ts
@@ -1,7 +1,6 @@
import crypto from "crypto";
import { FastifyReply, FastifyRequest } from "fastify";
import { z } from "zod";
-import { getUserHasAdminAccessToSite } from "../../lib/auth-utils.js";
import { siteConfig } from "../../lib/siteConfig.js";
// Schema for updating API configuration
@@ -11,10 +10,6 @@ const updatePrivateLinkConfigSchema = z.object({
export async function updateSitePrivateLinkConfig(request: FastifyRequest, reply: FastifyReply) {
try {
- if (!request.user) {
- return reply.status(401).send({ success: false, error: "Unauthorized" });
- }
-
const { siteId } = request.params as { siteId: string };
const parsedSiteId = parseInt(siteId, 10);
@@ -22,11 +17,6 @@ export async function updateSitePrivateLinkConfig(request: FastifyRequest, reply
return reply.status(400).send({ success: false, error: "Invalid site ID" });
}
- const userHasAdminAccessToSite = await getUserHasAdminAccessToSite(request, String(parsedSiteId));
- if (!userHasAdminAccessToSite) {
- return reply.status(403).send({ error: "Forbidden" });
- }
-
// Validate request body
const validationResult = updatePrivateLinkConfigSchema.safeParse(request.body);
if (!validationResult.success) {
diff --git a/server/src/api/user/addUserToOrganization.ts b/server/src/api/user/addUserToOrganization.ts
index 14fd2776d..c9cb6b583 100644
--- a/server/src/api/user/addUserToOrganization.ts
+++ b/server/src/api/user/addUserToOrganization.ts
@@ -2,9 +2,8 @@ import { and, eq } from "drizzle-orm";
import { FastifyReply, FastifyRequest } from "fastify";
import { db } from "../../db/postgres/postgres.js";
import { member, user } from "../../db/postgres/schema.js";
-
import { randomBytes } from "crypto";
-import { getIsUserAdmin, getUserIsInOrg } from "../../lib/auth-utils.js";
+import { getIsUserAdmin } from "../../lib/auth-utils.js";
function generateId(len = 32) {
const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -30,14 +29,20 @@ export async function addUserToOrganization(request: FastifyRequest<AddUserToOrg
try {
const { organizationId } = request.params;
const { email, role } = request.body;
+ const userId = request.user?.id;
- const [userIsInOrg, isAdmin] = await Promise.all([
- getUserIsInOrg(request, organizationId),
- getIsUserAdmin(request),
- ]);
+ const isAdmin = await getIsUserAdmin(request);
- if (!isAdmin && (!userIsInOrg || (userIsInOrg.role !== "admin" && userIsInOrg.role !== "owner"))) {
- return reply.status(401).send({ error: "Unauthorized" });
+ if (!isAdmin) {
+ if (!userId) {
+ return reply.status(401).send({ error: "Unauthorized" });
+ }
+ const userMembership = await db.query.member.findFirst({
+ where: and(eq(member.userId, userId), eq(member.organizationId, organizationId)),
+ });
+ if (!userMembership || (userMembership.role !== "admin" && userMembership.role !== "owner")) {
+ return reply.status(401).send({ error: "Unauthorized" });
+ }
}
// Validate input
diff --git a/server/src/api/user/createApiKey.ts b/server/src/api/user/createApiKey.ts
index abfa7743d..1909cdd90 100644
--- a/server/src/api/user/createApiKey.ts
+++ b/server/src/api/user/createApiKey.ts
@@ -1,6 +1,5 @@
import { FastifyRequest, FastifyReply } from "fastify";
import { z } from "zod";
-import { getSessionFromReq } from "../../lib/auth-utils.js";
import { auth } from "../../lib/auth.js";
const createApiKeySchema = z.object({
@@ -12,13 +11,11 @@ type CreateApiKeyBody = z.infer<typeof createApiKeySchema>;
export const createApiKey = async (request: FastifyRequest<{ Body: CreateApiKeyBody }>, reply: FastifyReply) => {
try {
- const session = await getSessionFromReq(request);
-
- if (!session?.user.id) {
+ const userId = request.user?.id;
+ if (!userId) {
return reply.status(401).send({ error: "Unauthorized" });
}
- // Validate request body
const validation = createApiKeySchema.safeParse(request.body);
if (!validation.success) {
return reply.status(400).send({
@@ -29,22 +26,18 @@ export const createApiKey = async (request: FastifyRequest<{ Body: CreateApiKeyB
const { name, expiresIn } = validation.data;
- // Create API key with Better Auth
- // Default rate limiting: 10,000 requests per day
const apiKey = await auth.api.createApiKey({
body: {
name,
- userId: session.user.id,
+ userId,
expiresIn,
rateLimitEnabled: true,
- rateLimitTimeWindow: 1000 * 60 * 10, // 10 minutes
+ rateLimitTimeWindow: 1000 * 60 * 10,
rateLimitMax: 500,
prefix: "rb_",
},
});
- // Return the full API key (including the key value)
- // This is the only time the key will be shown
return reply.send(apiKey);
} catch (error) {
console.error("Error creating API key:", error);
diff --git a/server/src/api/user/deleteApiKey.ts b/server/src/api/user/deleteApiKey.ts
index 53f39c4e5..a1171a645 100644
--- a/server/src/api/user/deleteApiKey.ts
+++ b/server/src/api/user/deleteApiKey.ts
@@ -1,5 +1,4 @@
import { FastifyRequest, FastifyReply } from "fastify";
-import { getSessionFromReq } from "../../lib/auth-utils.js";
import { auth } from "../../lib/auth.js";
export const deleteApiKey = async (
@@ -7,21 +6,12 @@ export const deleteApiKey = async (
reply: FastifyReply
) => {
try {
- const session = await getSessionFromReq(request);
-
- if (!session?.user.id) {
- return reply.status(401).send({ error: "Unauthorized" });
- }
-
- // Get keyId from URL params
const { keyId } = request.params;
if (!keyId) {
return reply.status(400).send({ error: "Key ID is required" });
}
- // Delete API key with Better Auth
- // Better Auth will verify that the key belongs to the authenticated user
const result = await auth.api.deleteApiKey({
body: { keyId },
headers: request.headers as any,
diff --git a/server/src/api/user/getUserOrganizations.ts b/server/src/api/user/getUserOrganizations.ts
index cac5e972d..335a7a69a 100644
--- a/server/src/api/user/getUserOrganizations.ts
+++ b/server/src/api/user/getUserOrganizations.ts
@@ -2,13 +2,11 @@ import { FastifyRequest, FastifyReply } from "fastify";
import { db } from "../../db/postgres/postgres.js";
import { eq } from "drizzle-orm";
import { member, organization } from "../../db/postgres/schema.js";
-import { getSessionFromReq } from "../../lib/auth-utils.js";
export const getUserOrganizations = async (request: FastifyRequest, reply: FastifyReply) => {
try {
- const session = await getSessionFromReq(request);
-
- if (!session?.user.id) {
+ const userId = request.user?.id;
+ if (!userId) {
return reply.status(401).send({ error: "Unauthorized" });
}
@@ -24,7 +22,7 @@ export const getUserOrganizations = async (request: FastifyRequest, reply: Fasti
})
.from(member)
.innerJoin(organization, eq(member.organizationId, organization.id))
- .where(eq(member.userId, session?.user.id));
+ .where(eq(member.userId, userId));
return reply.send(userOrganizations);
} catch (error) {
diff --git a/server/src/api/user/listApiKeys.ts b/server/src/api/user/listApiKeys.ts
index ec85880af..73e452098 100644
--- a/server/src/api/user/listApiKeys.ts
+++ b/server/src/api/user/listApiKeys.ts
@@ -1,16 +1,8 @@
import { FastifyRequest, FastifyReply } from "fastify";
-import { getSessionFromReq } from "../../lib/auth-utils.js";
import { auth } from "../../lib/auth.js";
export const listApiKeys = async (request: FastifyRequest, reply: FastifyReply) => {
try {
- const session = await getSessionFromReq(request);
-
- if (!session?.user.id) {
- return reply.status(401).send({ error: "Unauthorized" });
- }
-
- // Use Better Auth to list API keys for the current user
const apiKeys = await auth.api.listApiKeys({
headers: request.headers as any,
});
diff --git a/server/src/api/user/listOrganizationMembers.ts b/server/src/api/user/listOrganizationMembers.ts
index 954944a18..0d84e8769 100644
--- a/server/src/api/user/listOrganizationMembers.ts
+++ b/server/src/api/user/listOrganizationMembers.ts
@@ -1,8 +1,7 @@
-import { and, eq } from "drizzle-orm";
+import { eq } from "drizzle-orm";
import { FastifyReply, FastifyRequest } from "fastify";
import { db } from "../../db/postgres/postgres.js";
import { member, user } from "../../db/postgres/schema.js";
-import { getSessionFromReq } from "../../lib/auth-utils.js";
interface ListOrganizationMembersRequest {
Params: {
@@ -10,14 +9,6 @@ interface ListOrganizationMembersRequest {
};
}
-// Define user interface based on schema
-interface UserInfo {
- id: string;
- name: string | null;
- email: string;
- image: string | null;
-}
-
export async function listOrganizationMembers(
request: FastifyRequest<ListOrganizationMembersRequest>,
reply: FastifyReply
@@ -25,29 +16,6 @@ export async function listOrganizationMembers(
try {
const { organizationId } = request.params;
- const session = await getSessionFromReq(request);
-
- if (!session?.user?.id) {
- return reply.status(401).send({
- error: "Unauthorized",
- message: "You must be logged in to access this resource",
- });
- }
-
- // Check if user is a member of this organization
- const userMembership = await db.query.member.findFirst({
- where: and(eq(member.userId, session.user.id), eq(member.organizationId, organizationId)),
- });
-
- if (!userMembership) {
- return reply.status(403).send({
- error: "Forbidden",
- message: "You do not have access to this organization",
- });
- }
-
- // User has access, fetch all members of the organization
- // Use a direct SQL query approach instead of relations
const organizationMembers = await db
.select({
id: member.id,
diff --git a/server/src/api/user/updateAccountSettings.ts b/server/src/api/user/updateAccountSettings.ts
index 143153e6c..fa10630de 100644
--- a/server/src/api/user/updateAccountSettings.ts
+++ b/server/src/api/user/updateAccountSettings.ts
@@ -4,12 +4,9 @@ import { z } from "zod";
import { DateTime } from "luxon";
import { db } from "../../db/postgres/postgres.js";
import { user } from "../../db/postgres/schema.js";
-import { getSessionFromReq } from "../../lib/auth-utils.js";
-// Schema for account settings that can be updated
const updateAccountSettingsSchema = z.object({
sendAutoEmailReports: z.boolean().optional(),
- // Add more settings here in the future
});
export type UpdateAccountSettingsRequest = z.infer<typeof updateAccountSettingsSchema>;
@@ -19,13 +16,11 @@ export const updateAccountSettings = async (
reply: FastifyReply
) => {
try {
- const session = await getSessionFromReq(request);
-
- if (!session?.user.id) {
+ const userId = request.user?.id;
+ if (!userId) {
return reply.status(401).send({ error: "Unauthorized" });
}
- // Validate request body
const validation = updateAccountSettingsSchema.safeParse(request.body);
if (!validation.success) {
@@ -53,7 +48,7 @@ export const updateAccountSettings = async (
...updateData,
updatedAt: DateTime.now().toISO(),
})
- .where(eq(user.id, session.user.id))
+ .where(eq(user.id, userId))
.returning();
if (!updatedUser) {
diff --git a/server/src/index.ts b/server/src/index.ts
index 0129b1257..9affa58c6 100644
--- a/server/src/index.ts
+++ b/server/src/index.ts
@@ -71,7 +71,7 @@ import { createApiKey } from "./api/user/createApiKey.js";
import { deleteApiKey } from "./api/user/deleteApiKey.js";
import { initializeClickhouse } from "./db/clickhouse/clickhouse.js";
import { initPostgres } from "./db/postgres/initPostgres.js";
-import { getSessionFromReq, getUserHasAccessToSitePublic, mapHeaders } from "./lib/auth-utils.js";
+import { mapHeaders } from "./lib/auth-utils.js";
import { auth } from "./lib/auth.js";
import { IS_CLOUD } from "./lib/const.js";
import { siteConfig } from "./lib/siteConfig.js";
@@ -80,7 +80,6 @@ import { handleIdentify } from "./services/tracker/identifyService.js";
// need to import telemetry service here to start it
import { telemetryService } from "./services/telemetryService.js";
import { weeklyReportService } from "./services/weekyReports/weeklyReportService.js";
-import { extractSiteId, replacePathSiteId, resolveNumericSiteId } from "./utils.js";
import { getTrackingConfig } from "./api/sites/getTrackingConfig.js";
import { updateSitePrivateLinkConfig } from "./api/sites/updateSitePrivateLinkConfig.js";
import { getSitePrivateLinkConfig } from "./api/sites/getSitePrivateLinkConfig.js";
@@ -94,6 +93,26 @@ import { getSiteImports } from "./api/sites/getSiteImports.js";
import { createSiteImport } from "./api/sites/createSiteImport.js";
import { batchImportEvents } from "./api/sites/batchImportEvents.js";
import { deleteSiteImport } from "./api/sites/deleteSiteImport.js";
+import {
+ requireAuth,
+ requireAdmin,
+ requireSiteAccess,
+ requireSiteAdminAccess,
+ allowPublicSiteAccess,
+ requireOrgMember,
+ requireOrgAdminFromParams,
+ resolveSiteId,
+} from "./lib/auth-middleware.js";
+
+// Pre-composed middleware chains for common auth patterns
+// Cast as any to work around Fastify's type inference limitations with preHandler
+const publicSite = { preHandler: [resolveSiteId, allowPublicSiteAccess] as any };
+const authSite = { preHandler: [resolveSiteId, requireSiteAccess] as any };
+const adminSite = { preHandler: [resolveSiteId, requireSiteAdminAccess] as any };
+const authOnly = { preHandler: [requireAuth] as any };
+const adminOnly = { preHandler: [requireAdmin] as any };
+const orgMember = { preHandler: [requireOrgMember] as any };
+const orgAdminParams = { preHandler: [requireOrgAdminFromParams] as any };
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
@@ -203,125 +222,6 @@ server.register(
{ auth: auth! }
);
-const PUBLIC_ROUTES: string[] = [
- "/api/health",
- "/api/track",
- "/api/identify",
- "/api/script.js",
- "/api/script-full.js",
- "/api/replay.js",
- "/api/metrics.js",
- "/api/config",
- "/api/auth",
- "/api/auth/callback/google",
- "/api/auth/callback/github",
- "/api/gsc/callback",
- "/api/stripe/webhook",
- "/api/as/webhook",
- "/api/session-replay/record",
- "/api/admin/telemetry",
- "/api/site/tracking-config",
-];
-
-// Define analytics routes that can be public
-const ANALYTICS_ROUTES = [
- "/api/live-user-count/",
- "/api/overview/",
- "/api/overview-bucketed/",
- "/api/error-bucketed/",
- "/api/metric/",
- "/api/page-titles/",
- "/api/retention/",
- "/api/sites/",
- "/api/site-has-data/",
- "/api/site-is-public/",
- "/api/sessions/",
- "/api/users/",
- "/api/session-locations/",
- "/api/funnels/",
- "/api/journeys/",
- "/api/goals/",
- "/api/events/",
- "/api/events/outbound/",
- "/api/performance/overview/",
- "/api/performance/time-series/",
- "/api/performance/by-dimension/",
- "/api/error-names/",
- "/api/error-events/",
- "/api/session-replay/",
- "/api/gsc/data/",
- "/api/gsc/status/",
-];
-
-server.addHook("onRequest", async (request, reply) => {
- const { url } = request.raw;
-
- if (!url) return;
-
- let processedUrl = url;
-
- // Bypass auth for public routes (now including the prepended /api)
- if (PUBLIC_ROUTES.some(route => processedUrl.includes(route))) {
- return;
- }
-
- // Skip analytics route processing for site management endpoints
- // These routes use /api/sites/:id/... pattern but are NOT analytics routes
- const isSiteManagementRoute =
- /^\/api\/sites\/[^\/]+\/(config|private-link-config|excluded-ips|excluded-countries|imports)/.test(processedUrl);
-
- // Check if it's an analytics route and get site ID (now including the prepended /api)
- if (!isSiteManagementRoute && ANALYTICS_ROUTES.some(route => processedUrl.startsWith(route))) {
- const siteId = extractSiteId(processedUrl);
-
- if (siteId) {
- // Convert string ID to numeric ID if needed
- let resolvedSiteId = siteId;
- if (String(siteId).length > 4) {
- const numericSiteId = await resolveNumericSiteId(siteId);
- if (numericSiteId) {
- // Rewrite the URL with the numeric ID
- const newUrl = replacePathSiteId(processedUrl, numericSiteId);
- request.raw.url = newUrl;
- processedUrl = newUrl;
- resolvedSiteId = String(numericSiteId);
- // Also update the parsed params since Fastify has already parsed them
- const params = request.params as Record<string, string>;
- if (params && "site" in params) {
- params.site = resolvedSiteId;
- }
- } else {
- // String ID not found in database
- return reply.status(404).send({ error: "Site not found" });
- }
- }
-
- // Check all access methods: direct access, public site, or valid private key
- const hasAccess = await getUserHasAccessToSitePublic(request, resolvedSiteId);
-
- if (hasAccess) {
- // User has access via: direct access, public site, or valid private key
- // Skip auth requirement and allow the request through
- return;
- }
- }
- }
-
- try {
- const session = await getSessionFromReq(request);
-
- if (!session) {
- return reply.status(401).send({ error: "Unauthorized" });
- }
-
- // Attach session user info to request
- request.user = session.user;
- } catch (err) {
- console.error("Auth Error:", err);
- return reply.status(500).send({ error: "Auth check failed" });
- }
-});
-
// Serve analytics scripts with generic names to avoid ad-blocker detection
server.get("/api/script.js", async (_, reply) => reply.sendFile("script.js"));
server.get("/api/replay.js", async (_, reply) => reply.sendFile("rrweb.min.js"));
@@ -330,88 +230,88 @@ server.get("/api/metrics.js", async (_, reply) => reply.sendFile("web-vitals.iif
// WEB & PRODUCT ANALYTICS
// This endpoint gets called a lot so we don't want to log it
-server.get("/api/live-user-count/:site", { logLevel: "silent" }, getLiveUsercount);
-server.get("/api/overview/:site", getOverview);
-server.get("/api/overview-bucketed/:site", getOverviewBucketed);
-server.get("/api/metric/:site", getMetric);
-server.get("/api/page-titles/:site", getPageTitles);
-server.get("/api/error-names/:site", getErrorNames);
-server.get("/api/error-events/:site", getErrorEvents);
-server.get("/api/error-bucketed/:site", getErrorBucketed);
-server.get("/api/retention/:site", getRetention);
-server.get("/api/site-has-data/:site", getSiteHasData);
-server.get("/api/site-is-public/:site", getSiteIsPublic);
-server.get("/api/sessions/:site", getSessions);
-server.get("/api/sessions/:sessionId/:site", getSession);
-server.get("/api/events/:site", getEvents);
-server.get("/api/users/:site", getUsers);
-server.get("/api/users/session-count/:site", getUserSessionCount);
-server.get("/api/users/:userId/:site", getUserInfo);
-server.get("/api/session-locations/:site", getSessionLocations);
-server.get("/api/funnels/:site", getFunnels);
-server.get("/api/journeys/:site", getJourneys);
-server.post("/api/funnels/analyze/:site", getFunnel);
-server.post("/api/funnels/:stepNumber/sessions/:site", getFunnelStepSessions);
-server.post("/api/funnels/:site", createFunnel);
-server.delete("/api/funnels/:funnelId/:site", deleteFunnel);
-server.get("/api/goals/:site", getGoals);
-server.get("/api/goals/:goalId/sessions/:site", getGoalSessions);
-server.post("/api/goals/:site", createGoal);
-server.delete("/api/goals/:goalId/:site", deleteGoal);
-server.put("/api/goals/:goalId/:site", updateGoal);
-server.get("/api/events/names/:site", getEventNames);
-server.get("/api/events/properties/:site", getEventProperties);
-server.get("/api/events/outbound/:site", getOutboundLinks);
-server.get("/api/org-event-count/:organizationId", getOrgEventCount);
+server.get("/api/live-user-count/:siteId", { logLevel: "silent", ...publicSite }, getLiveUsercount);
+server.get("/api/overview/:siteId", publicSite, getOverview);
+server.get("/api/overview-bucketed/:siteId", publicSite, getOverviewBucketed);
+server.get("/api/metric/:siteId", publicSite, getMetric);
+server.get("/api/page-titles/:siteId", publicSite, getPageTitles);
+server.get("/api/error-names/:siteId", publicSite, getErrorNames);
+server.get("/api/error-events/:siteId", publicSite, getErrorEvents);
+server.get("/api/error-bucketed/:siteId", publicSite, getErrorBucketed);
+server.get("/api/retention/:siteId", publicSite, getRetention);
+server.get("/api/site-has-data/:siteId", publicSite, getSiteHasData);
+server.get("/api/site-is-public/:siteId", publicSite, getSiteIsPublic);
+server.get("/api/sessions/:siteId", publicSite, getSessions);
+server.get("/api/sessions/:sessionId/:siteId", publicSite, getSession);
+server.get("/api/events/:siteId", publicSite, getEvents);
+server.get("/api/users/:siteId", publicSite, getUsers);
+server.get("/api/users/session-count/:siteId", publicSite, getUserSessionCount);
+server.get("/api/users/:userId/:siteId", publicSite, getUserInfo);
+server.get("/api/session-locations/:siteId", publicSite, getSessionLocations);
+server.get("/api/funnels/:siteId", publicSite, getFunnels);
+server.get("/api/journeys/:siteId", publicSite, getJourneys);
+server.post("/api/funnels/analyze/:siteId", publicSite, getFunnel);
+server.post("/api/funnels/:stepNumber/sessions/:siteId", publicSite, getFunnelStepSessions);
+server.post("/api/funnels/:siteId", authSite, createFunnel);
+server.delete("/api/funnels/:funnelId/:siteId", authSite, deleteFunnel);
+server.get("/api/goals/:siteId", publicSite, getGoals);
+server.get("/api/goals/:goalId/sessions/:siteId", publicSite, getGoalSessions);
+server.post("/api/goals/:siteId", authSite, createGoal);
+server.delete("/api/goals/:goalId/:siteId", authSite, deleteGoal);
+server.put("/api/goals/:goalId/:siteId", authSite, updateGoal);
+server.get("/api/events/names/:siteId", publicSite, getEventNames);
+server.get("/api/events/properties/:siteId", publicSite, getEventProperties);
+server.get("/api/events/outbound/:siteId", publicSite, getOutboundLinks);
+server.get("/api/org-event-count/:organizationId", orgMember, getOrgEventCount);
// Performance Analytics
-server.get("/api/performance/overview/:site", getPerformanceOverview);
-server.get("/api/performance/time-series/:site", getPerformanceTimeSeries);
-server.get("/api/performance/by-dimension/:site", getPerformanceByDimension);
+server.get("/api/performance/overview/:siteId", publicSite, getPerformanceOverview);
+server.get("/api/performance/time-series/:siteId", publicSite, getPerformanceTimeSeries);
+server.get("/api/performance/by-dimension/:siteId", publicSite, getPerformanceByDimension);
// Session Replay
-server.post("/api/session-replay/record/:site", recordSessionReplay);
-server.get("/api/session-replay/list/:site", getSessionReplays);
-server.get("/api/session-replay/:sessionId/:site", getSessionReplayEvents);
-server.delete("/api/session-replay/:sessionId/:site", deleteSessionReplay);
+server.post("/api/session-replay/record/:siteId", recordSessionReplay); // Public - tracking endpoint
+server.get("/api/session-replay/list/:siteId", publicSite, getSessionReplays);
+server.get("/api/session-replay/:sessionId/:siteId", publicSite, getSessionReplayEvents);
+server.delete("/api/session-replay/:sessionId/:siteId", authSite, deleteSessionReplay);
// Sites
-server.get("/api/sites/:id", getSite);
-server.post("/api/sites", addSite);
-server.put("/api/sites/:id/config", updateSiteConfig);
-server.delete("/api/sites/:id", deleteSite);
-server.get("/api/sites/:siteId/private-link-config", getSitePrivateLinkConfig);
-server.post("/api/sites/:siteId/private-link-config", updateSitePrivateLinkConfig);
-server.get("/api/site/tracking-config/:siteId", getTrackingConfig);
-server.get("/api/sites/:siteId/excluded-ips", getSiteExcludedIPs);
-server.get("/api/sites/:siteId/excluded-countries", getSiteExcludedCountries);
+server.get("/api/sites/:siteId", publicSite, getSite);
+server.post("/api/sites/:organizationId", orgAdminParams, addSite);
+server.put("/api/sites/:siteId/config", adminSite, updateSiteConfig);
+server.delete("/api/sites/:siteId", adminSite, deleteSite);
+server.get("/api/sites/:siteId/private-link-config", adminSite, getSitePrivateLinkConfig);
+server.post("/api/sites/:siteId/private-link-config", adminSite, updateSitePrivateLinkConfig);
+server.get("/api/site/tracking-config/:siteId", getTrackingConfig); // Public - used by tracking script
+server.get("/api/sites/:siteId/excluded-ips", authSite, getSiteExcludedIPs);
+server.get("/api/sites/:siteId/excluded-countries", authSite, getSiteExcludedCountries);
// Site Imports
-server.get("/api/sites/:site/imports", getSiteImports);
-server.post("/api/sites/:site/imports", createSiteImport);
-server.post("/api/sites/:site/imports/:importId/events", batchImportEvents);
-server.delete("/api/sites/:site/imports/:importId", deleteSiteImport);
+server.get("/api/sites/:siteId/imports", adminSite, getSiteImports);
+server.post("/api/sites/:siteId/imports", adminSite, createSiteImport);
+server.post("/api/sites/:siteId/imports/:importId/events", adminSite, batchImportEvents);
+server.delete("/api/sites/:siteId/imports/:importId", adminSite, deleteSiteImport);
// Organizations
-server.get("/api/organizations/:organizationId/sites", getSitesFromOrg);
-server.get("/api/organizations/:organizationId/members", listOrganizationMembers);
-server.post("/api/organizations/:organizationId/members", addUserToOrganization);
+server.get("/api/organizations/:organizationId/sites", orgMember, getSitesFromOrg);
+server.get("/api/organizations/:organizationId/members", orgMember, listOrganizationMembers);
+server.post("/api/organizations/:organizationId/members", orgMember, addUserToOrganization);
// User
-server.get("/api/config", getConfig);
-server.get("/api/user/organizations", getUserOrganizations);
-server.post("/api/user/account-settings", updateAccountSettings);
-server.get("/api/user/api-keys", listApiKeys);
-server.post("/api/user/api-keys", createApiKey);
-server.delete("/api/user/api-keys/:keyId", deleteApiKey);
+server.get("/api/config", getConfig); // Public - returns app config
+server.get("/api/user/organizations", authOnly, getUserOrganizations);
+server.post("/api/user/account-settings", authOnly, updateAccountSettings);
+server.get("/api/user/api-keys", authOnly, listApiKeys);
+server.post("/api/user/api-keys", authOnly, createApiKey);
+server.delete("/api/user/api-keys/:keyId", authOnly, deleteApiKey);
// GOOGLE SEARCH CONSOLE
-server.get("/api/gsc/connect/:site", connectGSC);
-server.get("/api/gsc/callback", gscCallback);
-server.get("/api/gsc/status/:site", getGSCStatus);
-server.delete("/api/gsc/disconnect/:site", disconnectGSC);
-server.post("/api/gsc/select-property/:site", selectGSCProperty);
-server.get("/api/gsc/data/:site", getGSCData);
+server.get("/api/gsc/connect/:siteId", authSite, connectGSC);
+server.get("/api/gsc/callback", gscCallback); // Public - OAuth callback
+server.get("/api/gsc/status/:siteId", publicSite, getGSCStatus);
+server.delete("/api/gsc/disconnect/:siteId", authSite, disconnectGSC);
+server.post("/api/gsc/select-property/:siteId", authSite, selectGSCProperty);
+server.get("/api/gsc/data/:siteId", publicSite, getGSCData);
// UPTIME MONITORING
// Only register uptime routes when IS_CLOUD is true (Redis is available)
@@ -454,31 +354,28 @@ server.get("/api/gsc/data/:site", getGSCData);
if (IS_CLOUD) {
// Stripe Routes
- server.post("/api/stripe/create-checkout-session", createCheckoutSession);
- server.post("/api/stripe/create-portal-session", createPortalSession);
- server.post("/api/stripe/preview-subscription-update", previewSubscriptionUpdate);
- server.post("/api/stripe/update-subscription", updateSubscription);
- server.get("/api/stripe/subscription", getSubscription);
- server.post("/api/stripe/webhook", { config: { rawBody: true } }, handleWebhook); // Use rawBody parser config for webhook
+ server.post("/api/stripe/create-checkout-session", authOnly, createCheckoutSession);
+ server.post("/api/stripe/create-portal-session", authOnly, createPortalSession);
+ server.post("/api/stripe/preview-subscription-update", authOnly, previewSubscriptionUpdate);
+ server.post("/api/stripe/update-subscription", authOnly, updateSubscription);
+ server.get("/api/stripe/subscription", authOnly, getSubscription);
+ server.post("/api/stripe/webhook", { config: { rawBody: true } }, handleWebhook); // Public - Stripe webhook
// Admin Routes
- server.get("/api/admin/sites", getAdminSites);
- server.get("/api/admin/organizations", getAdminOrganizations);
- server.get("/api/admin/service-event-count", getAdminServiceEventCount);
- server.post("/api/admin/telemetry", collectTelemetry);
+ server.get("/api/admin/sites", adminOnly, getAdminSites);
+ server.get("/api/admin/organizations", adminOnly, getAdminOrganizations);
+ server.get("/api/admin/service-event-count", adminOnly, getAdminServiceEventCount);
+ server.post("/api/admin/telemetry", collectTelemetry); // Public - telemetry collection
// AppSumo Routes
const { activateAppSumoLicense } = await import("./api/as/activate.js");
const { handleAppSumoWebhook } = await import("./api/as/webhook.js");
- server.post("/api/as/activate", activateAppSumoLicense);
- server.post("/api/as/webhook", handleAppSumoWebhook);
+ server.post("/api/as/activate", authOnly, activateAppSumoLicense);
+ server.post("/api/as/webhook", handleAppSumoWebhook); // Public - AppSumo webhook
}
-server.post("/track", trackEvent);
server.post("/api/track", trackEvent);
-
-server.post("/identify", handleIdentify);
server.post("/api/identify", handleIdentify);
server.get("/api/health", { logLevel: "silent" }, (_, reply) => reply.send("OK"));
diff --git a/server/src/lib/auth-middleware.ts b/server/src/lib/auth-middleware.ts
new file mode 100644
index 000000000..96e44f035
--- /dev/null
+++ b/server/src/lib/auth-middleware.ts
@@ -0,0 +1,207 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import {
+ getSessionFromReq,
+ checkApiKey,
+ getUserHasAccessToSite,
+ getUserHasAdminAccessToSite,
+ getUserHasAccessToSitePublic,
+ getIsUserAdmin,
+ getUserIsInOrg,
+} from "./auth-utils.js";
+import { resolveNumericSiteId } from "../utils.js";
+import { db } from "../db/postgres/postgres.js";
+
+type AuthMiddleware = (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+
+const getSiteIdFromParams = (request: FastifyRequest): string | undefined => {
+ const params = request.params as Record<string, string>;
+ return params.siteId;
+};
+
+/**
+ * Resolves string site IDs to numeric IDs and updates request params.
+ * Should be first in preHandler chain for routes with site params.
+ */
+export const resolveSiteId: AuthMiddleware = async (request, reply) => {
+ const params = request.params as Record<string, string>;
+ const siteId = getSiteIdFromParams(request);
+
+ if (siteId && String(siteId).length > 4) {
+ const numericId = await resolveNumericSiteId(siteId);
+ if (!numericId) {
+ return reply.status(404).send({ error: "Site not found" });
+ }
+ params.siteId = String(numericId);
+ }
+};
+
+/**
+ * Requires valid session or API key. Attaches user to request if session available.
+ */
+export const requireAuth: AuthMiddleware = async (request, reply) => {
+ const session = await getSessionFromReq(request);
+ if (session?.user) {
+ request.user = session.user;
+ return;
+ }
+
+ // API key provides access but doesn't populate request.user
+ const apiKeyResult = await checkApiKey(request, {});
+ if (apiKeyResult.valid) {
+ return;
+ }
+
+ return reply.status(401).send({ error: "Unauthorized" });
+};
+
+/**
+ * Requires system admin role.
+ */
+export const requireAdmin: AuthMiddleware = async (request, reply) => {
+ const isAdmin = await getIsUserAdmin(request);
+ if (!isAdmin) {
+ return reply.status(401).send({ error: "Unauthorized" });
+ }
+ const session = await getSessionFromReq(request);
+ if (session?.user) request.user = session.user;
+};
+
+/**
+ * Requires access to site (via session or API key).
+ */
+export const requireSiteAccess: AuthMiddleware = async (request, reply) => {
+ const siteId = getSiteIdFromParams(request);
+ if (!siteId) {
+ return reply.status(400).send({ error: "Site ID required" });
+ }
+
+ // Check API key first (doesn't populate request.user)
+ const apiKeyResult = await checkApiKey(request, { siteId });
+ if (apiKeyResult.valid) {
+ return;
+ }
+
+ // Check session-based access
+ const hasAccess = await getUserHasAccessToSite(request, siteId);
+ if (!hasAccess) {
+ return reply.status(403).send({ error: "Forbidden" });
+ }
+
+ const session = await getSessionFromReq(request);
+ if (session?.user) request.user = session.user;
+};
+
+/**
+ * Requires admin/owner access to site.
+ */
+export const requireSiteAdminAccess: AuthMiddleware = async (request, reply) => {
+ const siteId = getSiteIdFromParams(request);
+ if (!siteId) {
+ return reply.status(400).send({ error: "Site ID required" });
+ }
+
+ // Check API key with admin/owner role first (doesn't populate request.user)
+ const apiKeyResult = await checkApiKey(request, { siteId });
+ if (apiKeyResult.valid && (apiKeyResult.role === "admin" || apiKeyResult.role === "owner")) {
+ return;
+ }
+
+ // Check session-based admin access
+ const hasAdminAccess = await getUserHasAdminAccessToSite(request, siteId);
+ if (!hasAdminAccess) {
+ return reply.status(403).send({ error: "Forbidden" });
+ }
+
+ const session = await getSessionFromReq(request);
+ if (session?.user) request.user = session.user;
+};
+
+/**
+ * Allows public site access, private key, or authenticated access.
+ */
+export const allowPublicSiteAccess: AuthMiddleware = async (request, reply) => {
+ const siteId = getSiteIdFromParams(request);
+ if (!siteId) {
+ return reply.status(400).send({ error: "Site ID required" });
+ }
+
+ const apiKeyResult = await checkApiKey(request, { siteId });
+ if (apiKeyResult.valid) {
+ return;
+ }
+
+ const hasAccess = await getUserHasAccessToSitePublic(request, siteId);
+ if (hasAccess) {
+ const session = await getSessionFromReq(request);
+ if (session?.user) request.user = session.user;
+ return;
+ }
+
+ return reply.status(403).send({ error: "Forbidden" });
+};
+
+/**
+ * Requires membership in organization.
+ */
+export const requireOrgMember: AuthMiddleware = async (request, reply) => {
+ const params = request.params as Record<string, string>;
+ const organizationId = params.organizationId;
+
+ if (!organizationId) {
+ return reply.status(400).send({ error: "Organization ID required" });
+ }
+
+ const apiKeyResult = await checkApiKey(request, { organizationId });
+ if (apiKeyResult.valid) {
+ return;
+ }
+
+ const isMember = await getUserIsInOrg(request, organizationId);
+ if (!isMember) {
+ return reply.status(403).send({ error: "Forbidden" });
+ }
+
+ const session = await getSessionFromReq(request);
+ if (session?.user) request.user = session.user;
+};
+
+/**
+ * Requires org admin/owner access via session or API key.
+ * Extracts organizationId from request params (orgId).
+ * Use for endpoints that create resources in an org (like addSite).
+ */
+export const requireOrgAdminFromParams: AuthMiddleware = async (request, reply) => {
+ const params = request.params as Record<string, string>;
+ const organizationId = params.organizationId;
+
+ if (!organizationId) {
+ return reply.status(400).send({ error: "Organization ID required in path" });
+ }
+
+ // Check API key first - must have admin/owner role
+ const apiKeyResult = await checkApiKey(request, { organizationId });
+ if (apiKeyResult.valid && (apiKeyResult.role === "admin" || apiKeyResult.role === "owner")) {
+ return;
+ }
+
+ // Check session-based access - must be admin/owner of org
+ const session = await getSessionFromReq(request);
+ if (!session?.user?.id) {
+ return reply.status(401).send({ error: "Unauthorized" });
+ }
+
+ // Check org membership and role
+ const member = await db.query.member.findFirst({
+ where: (member, { and, eq }) => and(eq(member.userId, session.user.id), eq(member.organizationId, organizationId)),
+ });
+
+ if (!member) {
+ return reply.status(403).send({ error: "You are not a member of this organization" });
+ }
+
+ if (member.role !== "admin" && member.role !== "owner") {
+ return reply.status(403).send({ error: "You must be an admin or owner" });
+ }
+
+ request.user = session.user;
+};
diff --git a/server/src/lib/auth-utils.ts b/server/src/lib/auth-utils.ts
index 9a0feaa82..4d8661de7 100644
--- a/server/src/lib/auth-utils.ts
+++ b/server/src/lib/auth-utils.ts
@@ -5,6 +5,7 @@ import { db } from "../db/postgres/postgres.js";
import { member, sites, user } from "../db/postgres/schema.js";
import { auth } from "./auth.js";
import { siteConfig } from "./siteConfig.js";
+import { logger } from "./logger/logger.js";
export function mapHeaders(headers: any) {
const entries = Object.entries(headers);
@@ -102,33 +103,15 @@ export async function getSitesUserHasAccessTo(req: FastifyRequest, adminOnly = f
return promise;
}
-// for routes that are potentially public
-export async function getUserHasAccessToSitePublic(req: FastifyRequest, siteId: string | number) {
- const [userSites, config] = await Promise.all([getSitesUserHasAccessTo(req), siteConfig.getConfig(siteId)]);
-
- // Check if user has direct access to the site
- const hasDirectAccess = userSites.some(site => site.siteId === Number(siteId));
- if (hasDirectAccess) {
- return true;
- }
-
- // Check if site is public
- if (config?.public) {
- return true;
- }
-
- // Check if a valid private key was provided in the header
- const privateKey = req.headers["x-private-key"];
- if (privateKey && typeof privateKey === "string" && config?.privateLinkKey === privateKey) {
- return true;
- }
-
+export async function checkApiKey(
+ req: FastifyRequest,
+ options: { organizationId?: string; siteId?: string | number }
+) {
// Check if a valid API key was provided
// Priority: 1. Authorization: Bearer header (recommended), 2. Query parameter (testing only)
const authHeader = req.headers["authorization"];
- const bearerToken = authHeader && typeof authHeader === "string" && authHeader.startsWith("Bearer ")
- ? authHeader.substring(7)
- : null;
+ const bearerToken =
+ authHeader && typeof authHeader === "string" && authHeader.startsWith("Bearer ") ? authHeader.substring(7) : null;
const queryApiKey = (req.query as any)?.api_key;
const apiKey = bearerToken || queryApiKey;
@@ -144,33 +127,71 @@ export async function getUserHasAccessToSitePublic(req: FastifyRequest, siteId:
// Get the userId from the API key
const apiKeyUserId = result.key.userId;
- // Get the site's organization
- const siteRecords = await db
- .select({
- organizationId: sites.organizationId,
- })
- .from(sites)
- .where(eq(sites.siteId, Number(siteId)))
- .limit(1);
+ // Determine the organization ID - either directly provided or looked up from site
+ let organizationId = options.organizationId;
+
+ if (!organizationId && options.siteId) {
+ // Get the site's organization
+ const siteRecords = await db
+ .select({
+ organizationId: sites.organizationId,
+ })
+ .from(sites)
+ .where(eq(sites.siteId, Number(options.siteId)))
+ .limit(1);
+
+ if (siteRecords.length > 0 && siteRecords[0].organizationId) {
+ organizationId = siteRecords[0].organizationId;
+ }
+ }
- if (siteRecords.length > 0 && siteRecords[0].organizationId) {
+ if (organizationId) {
// Check if the API key's user is a member of the organization
const userMembership = await db
.select()
.from(member)
- .where(and(eq(member.userId, apiKeyUserId), eq(member.organizationId, siteRecords[0].organizationId)))
+ .where(and(eq(member.userId, apiKeyUserId), eq(member.organizationId, organizationId)))
.limit(1);
if (userMembership.length > 0) {
- return true;
+ return { valid: true, role: userMembership[0].role };
}
}
+ return { valid: false, role: null };
}
} catch (error) {
- console.error("Error verifying API key:", error);
+ logger.error(error, "Error verifying API key");
// Continue to return false if API key verification fails
}
}
+ return { valid: false, role: null };
+}
+
+// for routes that are potentially public
+export async function getUserHasAccessToSitePublic(req: FastifyRequest, siteId: string | number) {
+ const [userSites, config] = await Promise.all([getSitesUserHasAccessTo(req), siteConfig.getConfig(siteId)]);
+
+ // Check if user has direct access to the site
+ const hasDirectAccess = userSites.some(site => site.siteId === Number(siteId));
+ if (hasDirectAccess) {
+ return true;
+ }
+
+ // Check if site is public
+ if (config?.public) {
+ return true;
+ }
+
+ // Check if a valid private key was provided in the header
+ const privateKey = req.headers["x-private-key"];
+ if (privateKey && typeof privateKey === "string" && config?.privateLinkKey === privateKey) {
+ return true;
+ }
+
+ const result = await checkApiKey(req, { siteId });
+ if (result.valid) {
+ return true;
+ }
return false;
}