@iann29/rastro 0.1.0-alpha.0

package/src/component/http.ts

@@ -0,0 +1,301 @@
+import { httpRouter } from "convex/server";
+import { ConvexError } from "convex/values";
+import type { Id } from "./_generated/dataModel.js";
+import { api } from "./_generated/api.js";
+import { httpAction } from "./_generated/server.js";
+import { MAX_BATCH_BYTES } from "./constants.js";
+import { isPlainRecord } from "./guards.js";
+import type { TrackerEvent } from "./validators.js";
+import {
+  TRACKER_GZIP_BASE64,
+  TRACKER_GZIP_BYTES,
+} from "../tracker/generated.js";
+
+const TRACKER_GZIP = Uint8Array.from(
+  atob(TRACKER_GZIP_BASE64),
+  (character) => character.charCodeAt(0),
+);
+
+const http = httpRouter();
+
+http.route({
+  path: "/events",
+  method: "POST",
+  handler: httpAction(async (ctx, request) => {
+    const origin = request.headers.get("origin");
+    if (!origin) return json({ error: { code: "ORIGIN_REQUIRED" } }, 400);
+    const bytes = await request.arrayBuffer();
+    if (bytes.byteLength > MAX_BATCH_BYTES) {
+      return json({ error: { code: "BATCH_TOO_LARGE", limitBytes: MAX_BATCH_BYTES } }, 413);
+    }
+
+    let payload: { siteId: string; events: TrackerEvent[] };
+    try {
+      const parsed: unknown = JSON.parse(new TextDecoder().decode(bytes));
+      payload = parsePayload(parsed);
+    } catch (error) {
+      return json(
+        {
+          error: {
+            code: "INVALID_BODY",
+            message: error instanceof Error ? error.message : "invalid JSON body",
+          },
+        },
+        400,
+      );
+    }
+
+    const userAgent = request.headers.get("user-agent") ?? "";
+    const context = {
+      country: firstHeader(request, ["x-vercel-ip-country", "cf-ipcountry"]),
+      city: decodeHeader(firstHeader(request, ["x-vercel-ip-city", "cf-ipcity"])),
+      latitude: numericHeader(request, ["x-vercel-ip-latitude", "cf-iplatitude"]),
+      longitude: numericHeader(request, ["x-vercel-ip-longitude", "cf-iplongitude"]),
+      ...classifyUserAgent(userAgent),
+    };
+
+    try {
+      const result = await ctx.runMutation(api.ingest.ingestBatch, {
+        siteId: payload.siteId as Id<"sites">,
+        origin,
+        events: payload.events,
+        context,
+      });
+      return json(result, 200, corsHeaders(origin));
+    } catch (error) {
+      if (error instanceof ConvexError) {
+        const data = error.data as { code?: string; message?: string };
+        const status =
+          data.code === "ORIGIN_NOT_ALLOWED"
+            ? 403
+            : data.code === "RATE_LIMITED"
+              ? 429
+              : 400;
+        return json({ error: data }, status);
+      }
+      return json({ error: { code: "INVALID_REQUEST" } }, 400);
+    }
+  }),
+});
+
+http.route({
+  path: "/events",
+  method: "OPTIONS",
+  handler: httpAction(async (_ctx, request) => {
+    const origin = request.headers.get("origin");
+    if (!origin) return new Response(null, { status: 400 });
+    try {
+      const url = new URL(origin);
+      if (url.protocol !== "http:" && url.protocol !== "https:") {
+        return new Response(null, { status: 403 });
+      }
+      return new Response(null, { status: 204, headers: corsHeaders(origin) });
+    } catch {
+      return new Response(null, { status: 400 });
+    }
+  }),
+});
+http.route({
+  path: "/tracker.js",
+  method: "GET",
+  handler: httpAction(async () => {
+    return new Response(TRACKER_GZIP, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/javascript; charset=utf-8",
+        "Content-Encoding": "gzip",
+        "Content-Length": String(TRACKER_GZIP_BYTES),
+        "Cache-Control": "public, max-age=300, stale-while-revalidate=86400",
+        "Access-Control-Allow-Origin": "*",
+        Vary: "Accept-Encoding",
+      },
+    });
+  }),
+});
+
+
+http.route({
+  path: "/health",
+  method: "GET",
+  handler: httpAction(async () => {
+    return json(
+      { ok: true, component: "@iann29/rastro" },
+      200,
+      {
+        "Access-Control-Allow-Origin": "*",
+        "Cache-Control": "no-store",
+      },
+    );
+  }),
+});
+
+function parsePayload(value: unknown): { siteId: string; events: TrackerEvent[] } {
+  if (!isPlainRecord(value) || typeof value.siteId !== "string" || !Array.isArray(value.events)) {
+    throw new Error("body must contain siteId and events");
+  }
+  return { siteId: value.siteId, events: value.events.map(parseEvent) };
+}
+
+function parseEvent(value: unknown): TrackerEvent {
+  if (!isPlainRecord(value)) throw new Error("each event must be an object");
+  const type = value.type;
+  if (
+    type !== "pageview" &&
+    type !== "click" &&
+    type !== "custom" &&
+    type !== "conversion" &&
+    type !== "heartbeat" &&
+    type !== "outbound"
+  ) {
+    throw new Error("event type is invalid");
+  }
+  if (
+    typeof value.eventId !== "string" ||
+    typeof value.sessionId !== "string" ||
+    typeof value.visitorId !== "string" ||
+    typeof value.path !== "string" ||
+    typeof value.timestamp !== "number" ||
+    typeof value.sequence !== "number"
+  ) {
+    throw new Error("event is missing required fields");
+  }
+  const properties = parseProperties(value.properties);
+  return {
+    eventId: value.eventId,
+    sessionId: value.sessionId,
+    visitorId: value.visitorId,
+    type,
+    ...(optionalString(value.name, "name") !== undefined
+      ? { name: optionalString(value.name, "name") }
+      : {}),
+    path: value.path,
+    ...(optionalString(value.referrer, "referrer") !== undefined
+      ? { referrer: optionalString(value.referrer, "referrer") }
+      : {}),
+    timestamp: value.timestamp,
+    sequence: value.sequence,
+    ...(optionalString(value.target, "target") !== undefined
+      ? { target: optionalString(value.target, "target") }
+      : {}),
+    ...(optionalString(value.href, "href") !== undefined
+      ? { href: optionalString(value.href, "href") }
+      : {}),
+    ...(properties ? { properties } : {}),
+    ...(optionalNumber(value.revenueCents, "revenueCents") !== undefined
+      ? { revenueCents: optionalNumber(value.revenueCents, "revenueCents") }
+      : {}),
+    ...(optionalString(value.currency, "currency") !== undefined
+      ? { currency: optionalString(value.currency, "currency") }
+      : {}),
+    ...(optionalString(value.affiliateSlug, "affiliateSlug") !== undefined
+      ? { affiliateSlug: optionalString(value.affiliateSlug, "affiliateSlug") }
+      : {}),
+  };
+}
+
+function parseProperties(value: unknown): TrackerEvent["properties"] {
+  if (value === undefined) return undefined;
+  if (!isPlainRecord(value)) throw new Error("properties must be an object");
+  const result: NonNullable<TrackerEvent["properties"]> = {};
+  for (const [key, property] of Object.entries(value)) {
+    if (
+      typeof property !== "string" &&
+      typeof property !== "number" &&
+      typeof property !== "boolean" &&
+      property !== null
+    ) {
+      throw new Error(`property ${key} has an invalid value`);
+    }
+    result[key] = property;
+  }
+  return result;
+}
+
+function optionalString(value: unknown, field: string): string | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== "string") throw new Error(`${field} must be a string`);
+  return value;
+}
+
+function optionalNumber(value: unknown, field: string): number | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== "number") throw new Error(`${field} must be a number`);
+  return value;
+}
+
+
+function firstHeader(request: Request, names: string[]): string | undefined {
+  for (const name of names) {
+    const value = request.headers.get(name);
+    if (value) return value;
+  }
+  return undefined;
+}
+
+function numericHeader(request: Request, names: string[]): number | undefined {
+  const value = firstHeader(request, names);
+  if (!value) return undefined;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : undefined;
+}
+
+function decodeHeader(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function classifyUserAgent(userAgent: string): {
+  browser: string;
+  os: string;
+  device: string;
+} {
+  const browser = /Edg\//.test(userAgent)
+    ? "Edge"
+    : /Firefox\//.test(userAgent)
+      ? "Firefox"
+      : /Chrome\//.test(userAgent)
+        ? "Chrome"
+        : /Safari\//.test(userAgent)
+          ? "Safari"
+          : "Other";
+  const os = /Android/.test(userAgent)
+    ? "Android"
+    : /iPhone|iPad/.test(userAgent)
+      ? "iOS"
+      : /Windows/.test(userAgent)
+        ? "Windows"
+        : /Mac OS X/.test(userAgent)
+          ? "macOS"
+          : /Linux/.test(userAgent)
+            ? "Linux"
+            : "Other";
+  const device = /iPad|Tablet/.test(userAgent)
+    ? "tablet"
+    : /Mobile|Android|iPhone/.test(userAgent)
+      ? "mobile"
+      : "desktop";
+  return { browser, os, device };
+}
+
+function corsHeaders(origin: string): HeadersInit {
+  return {
+    "Access-Control-Allow-Origin": origin,
+    "Access-Control-Allow-Methods": "POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type",
+    "Access-Control-Max-Age": "86400",
+    Vary: "Origin",
+  };
+}
+
+function json(value: unknown, status: number, headers?: HeadersInit): Response {
+  return new Response(JSON.stringify(value), {
+    status,
+    headers: { "Content-Type": "application/json; charset=utf-8", ...headers },
+  });
+}
+
+export default http;