@njinlabs/njin 0.10.2 → 0.11.0-beta.1

package/src/core/model/index.ts

@@ -1,7 +1,7 @@
-import surreal from "../../modules/surreal";
 import moment from "moment";
 import { RecordId, Table, type Values } from "surrealdb";
-import { z } from "zod";
+import type { z } from "zod";
+import surreal from "../../modules/surreal";
 import { runAfterHooks, runBeforeDestroyHooks, runBeforeHooks } from "./hooks";
 
 // See the containment-boost comment in read()'s relevanceSelect below for why this exists and
@@ -53,18 +53,20 @@ export type ReadOptions = {
   filters?: Record<string, FilterValue>;
 };
 
-
 // Whitelist of operators — unknown operators are silently dropped, never interpolated.
-const OPERATORS: Record<FilterOperator, (field: string, param: string) => string> = {
-  $eq:         (f, p) => `${f} = $${p}`,
-  $ne:         (f, p) => `${f} != $${p}`,
-  $gt:         (f, p) => `${f} > $${p}`,
-  $gte:        (f, p) => `${f} >= $${p}`,
-  $lt:         (f, p) => `${f} < $${p}`,
-  $lte:        (f, p) => `${f} <= $${p}`,
-  $contains:   (f, p) => `string::contains(string::lowercase(${f}), $${p})`,
+const OPERATORS: Record<
+  FilterOperator,
+  (field: string, param: string) => string
+> = {
+  $eq: (f, p) => `${f} = $${p}`,
+  $ne: (f, p) => `${f} != $${p}`,
+  $gt: (f, p) => `${f} > $${p}`,
+  $gte: (f, p) => `${f} >= $${p}`,
+  $lt: (f, p) => `${f} < $${p}`,
+  $lte: (f, p) => `${f} <= $${p}`,
+  $contains: (f, p) => `string::contains(string::lowercase(${f}), $${p})`,
   $startsWith: (f, p) => `string::starts_with(string::lowercase(${f}), $${p})`,
-  $in:         (f, p) => `${f} CONTAINS $${p}`,
+  $in: (f, p) => `${f} CONTAINS $${p}`,
 };
 
 const RELATION_RENDER_AS = ["relation", "multi_relation", "file", "multi_file"];
@@ -78,19 +80,31 @@ const schemaRegistry = new Map<string, z.ZodObject>();
 
 export type ResolvedSearchField =
   | { kind: "flat"; field: string }
-  | { kind: "nested"; local: string; targetPrefix: string; targetField: string; multi: boolean };
+  | {
+      kind: "nested";
+      local: string;
+      targetPrefix: string;
+      targetField: string;
+      multi: boolean;
+    };
 
 // Parses searchFields entries into flat field names and single-hop nested
 // "relationField.targetField" references, validating relation-family fields and
 // (when the target model has already registered itself) the target field's existence
 // synchronously — so a bad reference throws at model-definition time, not per-request.
-export const resolveSearchPlan = (schema: z.ZodObject, searchFields: string[], modelName: string): ResolvedSearchField[] => {
+export const resolveSearchPlan = (
+  schema: z.ZodObject,
+  searchFields: string[],
+  modelName: string,
+): ResolvedSearchField[] => {
   return searchFields.map((raw): ResolvedSearchField => {
     const dot = raw.indexOf(".");
     if (dot === -1) return { kind: "flat", field: raw };
 
     if (raw.indexOf(".", dot + 1) !== -1) {
-      throw new Error(`Model "${modelName}": searchFields entry "${raw}" has more than one level of nesting — only a single relation hop is supported.`);
+      throw new Error(
+        `Model "${modelName}": searchFields entry "${raw}" has more than one level of nesting — only a single relation hop is supported.`,
+      );
     }
 
     const local = raw.slice(0, dot);
@@ -98,13 +112,17 @@ export const resolveSearchPlan = (schema: z.ZodObject, searchFields: string[], m
     const meta = (schema.shape[local] as z.ZodType | undefined)?.meta() as any;
 
     if (!meta || !RELATION_RENDER_AS.includes(meta.renderAs)) {
-      throw new Error(`Model "${modelName}": searchFields entry "${raw}" references "${local}", which is not a relation/file field on this model's schema.`);
+      throw new Error(
+        `Model "${modelName}": searchFields entry "${raw}" references "${local}", which is not a relation/file field on this model's schema.`,
+      );
     }
 
     const targetPrefix = meta.model as string;
     const targetSchema = schemaRegistry.get(targetPrefix);
     if (targetSchema && !(targetField in targetSchema.shape)) {
-      throw new Error(`Model "${modelName}": searchFields entry "${raw}" references field "${targetField}", which does not exist on model "${targetPrefix}".`);
+      throw new Error(
+        `Model "${modelName}": searchFields entry "${raw}" references field "${targetField}", which does not exist on model "${targetPrefix}".`,
+      );
     }
 
     return {
@@ -112,7 +130,8 @@ export const resolveSearchPlan = (schema: z.ZodObject, searchFields: string[], m
       local,
       targetPrefix,
       targetField,
-      multi: meta.renderAs === "multi_relation" || meta.renderAs === "multi_file",
+      multi:
+        meta.renderAs === "multi_relation" || meta.renderAs === "multi_file",
     };
   });
 };
@@ -145,7 +164,11 @@ export const makeModel = <Rules extends z.ZodObject>(
 
   const relationFieldSet = new Set(relationFields);
 
-  const searchPlan = resolveSearchPlan(config.schema, config.searchFields, config.name);
+  const searchPlan = resolveSearchPlan(
+    config.schema,
+    config.searchFields,
+    config.name,
+  );
 
   const uniqueFields = Object.entries(config.schema.shape)
     .filter(([, v]) => (v as z.ZodType).meta()?.unique === true)
@@ -161,19 +184,29 @@ export const makeModel = <Rules extends z.ZodObject>(
   const filterableFieldSet = new Set(Object.keys(config.schema.shape));
 
   // field must be a known unique field — prevents arbitrary field injection
-  const isDuplicate = async (field: string, value: unknown, excludeId?: string) => {
+  const isDuplicate = async (
+    field: string,
+    value: unknown,
+    excludeId?: string,
+  ) => {
     if (!uniqueFieldSet.has(field)) return false;
 
     const excludeClause = excludeId ? "AND id != $excludeId" : "";
     const [[row]] = await surreal().query<[{ count: number }[]]>(
       `SELECT count() AS count FROM ${prefix} WHERE ${field} = $value ${excludeClause} GROUP ALL`,
-      { value, excludeId: excludeId ? new RecordId(table, excludeId) : undefined },
+      {
+        value,
+        excludeId: excludeId ? new RecordId(table, excludeId) : undefined,
+      },
     );
 
     return (row?.count ?? 0) > 0;
   };
 
-  const assertUnique = async (data: Record<string, unknown>, excludeId?: string) => {
+  const assertUnique = async (
+    data: Record<string, unknown>,
+    excludeId?: string,
+  ) => {
     for (const field of uniqueFields) {
       const value = data[field];
       if (value === undefined) continue; // partial update without this field — nothing to check
@@ -185,13 +218,22 @@ export const makeModel = <Rules extends z.ZodObject>(
   };
 
   const create = async (data: Values<Data>) => {
-    const merged = (await runBeforeHooks("beforeCreate", prefix, data as Record<string, unknown>, {})) as Values<Data>;
+    const merged = (await runBeforeHooks(
+      "beforeCreate",
+      prefix,
+      data as Record<string, unknown>,
+      {},
+    )) as Values<Data>;
 
     await assertUnique(merged);
 
     const record = (await surreal()
       .create<Data>(table)
-      .content({ ...merged, createdAt: moment().toISOString(), updatedAt: moment().toISOString() })
+      .content({
+        ...merged,
+        createdAt: moment().toISOString(),
+        updatedAt: moment().toISOString(),
+      })
       .output("after")
       .then(([data]) => data)) as Returning;
 
@@ -246,7 +288,10 @@ export const makeModel = <Rules extends z.ZodObject>(
           whereParts.push(`${key} = $f_${key}`);
         } else {
           // Operator form: filters[field][$op]=value
-          for (const [op, opValue] of Object.entries(value) as [FilterOperator, string][]) {
+          for (const [op, opValue] of Object.entries(value) as [
+            FilterOperator,
+            string,
+          ][]) {
             const builder = OPERATORS[op]; // strict whitelist — unknown ops get undefined
             if (!builder || opValue === undefined) continue;
 
@@ -264,7 +309,12 @@ export const makeModel = <Rules extends z.ZodObject>(
     const where = whereParts.length ? `WHERE ${whereParts.join(" AND ")}` : "";
     // id/createdAt/updatedAt are always present on every record but aren't part of the
     // user-defined schema shape (they're injected in create()/update()) — allow sorting by them too.
-    const sortableFields = new Set([...Object.keys(config.schema.shape), "id", "createdAt", "updatedAt"]);
+    const sortableFields = new Set([
+      ...Object.keys(config.schema.shape),
+      "id",
+      "createdAt",
+      "updatedAt",
+    ]);
     const hasExplicitSort = Boolean(sort && sortableFields.has(sort));
     // An explicit sort always wins; otherwise, when searching, rank by relevance instead of
     // leaving result order unspecified. `ORDER BY` only accepts a bare identifier here, not a
@@ -296,7 +346,8 @@ export const makeModel = <Rules extends z.ZodObject>(
     // data routinely writes a multi-word term as one run-together token (e.g. "REDWING 2415..."
     // for "Red Wing") — a plain substring check against "red wing" (with the space) would miss
     // that despite it being a stronger match than most ngram overlaps.
-    const useRelevance = !hasExplicitSort && Boolean(search && searchPlan.length);
+    const useRelevance =
+      !hasExplicitSort && Boolean(search && searchPlan.length);
     const orderBy = hasExplicitSort
       ? `ORDER BY ${sort} ${order === "desc" ? "DESC" : "ASC"}`
       : useRelevance
@@ -308,11 +359,14 @@ export const makeModel = <Rules extends z.ZodObject>(
       ? `, (${searchPlan
           .map((e, i) => {
             const n = i + 1;
-            const boost = (field: string) => `(IF ${containmentCheck(field)} THEN ${CONTAINMENT_BOOST} ELSE 0 END)`;
+            const boost = (field: string) =>
+              `(IF ${containmentCheck(field)} THEN ${CONTAINMENT_BOOST} ELSE 0 END)`;
             if (e.kind === "flat") {
               return `(search::score(${n}) + ${boost(e.field)})`;
             }
-            const idFilter = e.multi ? `id IN $parent.${e.local}` : `id = $parent.${e.local}`;
+            const idFilter = e.multi
+              ? `id IN $parent.${e.local}`
+              : `id = $parent.${e.local}`;
             return `math::sum((SELECT VALUE (search::score(${n}) + ${boost(e.targetField)}) FROM ${e.targetPrefix} WHERE ${idFilter} AND ${e.targetField} @${n}@ $search))`;
           })
           .join(" + ")}) AS __relevance`
@@ -328,7 +382,9 @@ export const makeModel = <Rules extends z.ZodObject>(
     const fetch = fetchFields.length ? `FETCH ${fetchFields.join(", ")}` : "";
     const start = (page - 1) * pageLimit;
 
-    const [rows, [countRow]] = await surreal().query<[(Returning & { __relevance?: number })[], { count: number }[]]>(
+    const [rows, [countRow]] = await surreal().query<
+      [(Returning & { __relevance?: number })[], { count: number }[]]
+    >(
       `SELECT *${relevanceSelect} FROM ${prefix} ${where} ${orderBy} LIMIT ${pageLimit} START ${start} ${fetch};
        SELECT count() as count FROM ${prefix} ${where} GROUP ALL`,
       params,
@@ -355,14 +411,20 @@ export const makeModel = <Rules extends z.ZodObject>(
 
   const show = (id: string) => {
     let q = surreal().select<Data>(new RecordId(table, id));
-    if (relationFields.length) q = q.fetch(...(relationFields as [string, ...string[]])) as typeof q;
+    if (relationFields.length)
+      q = q.fetch(...(relationFields as [string, ...string[]])) as typeof q;
     return q as unknown as Promise<Returning>;
   };
 
   const update = async (id: string, data: Values<Partial<Data>>) => {
-    const merged = (await runBeforeHooks("beforeUpdate", prefix, data as Record<string, unknown>, {
-      id,
-    })) as Values<Partial<Data>>;
+    const merged = (await runBeforeHooks(
+      "beforeUpdate",
+      prefix,
+      data as Record<string, unknown>,
+      {
+        id,
+      },
+    )) as Values<Partial<Data>>;
 
     await assertUnique(merged, id);
 
@@ -381,7 +443,9 @@ export const makeModel = <Rules extends z.ZodObject>(
   const destroy = async (id: string) => {
     await runBeforeDestroyHooks(prefix, id);
 
-    const record = (await (surreal().delete<Data>(new RecordId(table, id)) as unknown as Promise<Returning>)) as Returning;
+    const record = (await (surreal().delete<Data>(
+      new RecordId(table, id),
+    ) as unknown as Promise<Returning>)) as Returning;
 
     await runAfterHooks("afterDestroy", prefix, record);
 
@@ -402,10 +466,10 @@ export const makeModel = <Rules extends z.ZodObject>(
   };
 };
 
-export * from "./data_type";
-export * from "./hooks";
 export * from "../event";
 export * from "../helper";
 export * from "../plugin";
 export * from "../route";
 export * from "../vars";
+export * from "./data_type";
+export * from "./hooks";

package/src/core/path_guard.ts

@@ -3,14 +3,21 @@ import { basename, join, normalize, sep } from "node:path";
 // Resolves `requestedPath` against `baseDir` and rejects anything that escapes it
 // (e.g. "../../etc/passwd") — shared by every module that serves files straight
 // off disk based on a request path (uploads, admin panel SPA, etc).
-export const resolveSafePath = (baseDir: string, requestedPath: string): string | null => {
+export const resolveSafePath = (
+  baseDir: string,
+  requestedPath: string,
+): string | null => {
   // A bare `startsWith` prefix check would let "/app/uploads-evil" pass for a
   // baseDir of "/app/uploads" — anchor the comparison to a directory boundary
   // instead so only baseDir itself (or a path inside it) matches.
   const normalizedBase = normalize(baseDir);
-  const boundary = normalizedBase.endsWith(sep) ? normalizedBase : normalizedBase + sep;
+  const boundary = normalizedBase.endsWith(sep)
+    ? normalizedBase
+    : normalizedBase + sep;
   const resolved = normalize(join(baseDir, requestedPath));
-  return resolved === normalizedBase || resolved.startsWith(boundary) ? resolved : null;
+  return resolved === normalizedBase || resolved.startsWith(boundary)
+    ? resolved
+    : null;
 };
 
 // Strips any directory component from a client-supplied filename (e.g. a multipart

package/src/core/plugin.ts

@@ -1,4 +1,11 @@
-import type { EventFactory, HelperFactory, HookFactory, ModelFactory, RouteFactory, VarsFactory } from "./config";
+import type {
+  EventFactory,
+  HelperFactory,
+  HookFactory,
+  ModelFactory,
+  RouteFactory,
+  VarsFactory,
+} from "./config";
 
 export type Plugin = {
   models?: ModelFactory[];

package/src/core/public_url.ts

@@ -0,0 +1,24 @@
+import { getConfig } from "./config";
+
+// The base URL clients actually reach the site on. config.publicUrl wins; otherwise it is
+// derived from the request, honouring a reverse proxy's X-Forwarded-* headers — those are
+// only trusted for building discovery documents, never for any access decision.
+export const publicBase = (request: Request) => {
+  const configured = getConfig().publicUrl;
+  if (configured) {
+    // Not a /\/+$/ regex — that is quadratic on a long run of slashes.
+    let base = configured;
+    while (base.endsWith("/")) base = base.slice(0, -1);
+    return base;
+  }
+
+  const url = new URL(request.url);
+  const first = (name: string) =>
+    request.headers.get(name)?.split(",")[0]?.trim();
+
+  const proto = first("x-forwarded-proto") ?? url.protocol.replace(":", "");
+  const host =
+    first("x-forwarded-host") ?? request.headers.get("host") ?? url.host;
+
+  return `${proto}://${host}`;
+};

package/src/core/route.ts

@@ -3,4 +3,5 @@ import { Elysia } from "elysia";
 // Thin factory over Elysia itself — purely for DX (autocomplete/type-checking),
 // same purpose as defineConfig. Custom route files get the full Elysia API
 // (schema validation, guards, groups, macros, ...) with no wrapping layer.
-export const route = (config?: ConstructorParameters<typeof Elysia>[0]) => new Elysia(config);
+export const route = (config?: ConstructorParameters<typeof Elysia>[0]) =>
+  new Elysia(config);

package/src/core/vars/index.ts

@@ -1,7 +1,7 @@
-import surreal from "../../modules/surreal";
 import moment from "moment";
 import { RecordId, Table, type Values } from "surrealdb";
-import { z } from "zod";
+import type { z } from "zod";
+import surreal from "../../modules/surreal";
 import { runAfterHooks, runBeforeHooks } from "../model/hooks";
 
 // One shared physical table for every VARS group — rows are keyed by each
@@ -26,9 +26,16 @@ export const makeVars = <Rules extends z.ZodObject>(
   // returns a complete, valid object. Every VARS field is expected to
   // declare a .default(...) for this reason.
   const get = async (): Promise<Returning> => {
-    const record = await surreal().select<Data & { updatedAt?: string }>(recordId);
-    const { updatedAt, ...rest } = (record ?? {}) as Record<string, unknown> & { updatedAt?: string };
-    return { ...(config.schema.parse(rest) as Data), updatedAt: updatedAt ?? null };
+    const record = await surreal().select<Data & { updatedAt?: string }>(
+      recordId,
+    );
+    const { updatedAt, ...rest } = (record ?? {}) as Record<string, unknown> & {
+      updatedAt?: string;
+    };
+    return {
+      ...(config.schema.parse(rest) as Data),
+      updatedAt: updatedAt ?? null,
+    };
   };
 
   // Upsert, not update — the row may not exist yet on first save.
@@ -42,11 +49,18 @@ export const makeVars = <Rules extends z.ZodObject>(
 
     const record = (await surreal()
       .upsert<Data & { updatedAt: string }>(recordId)
-      .merge({ ...merged, updatedAt: moment().toISOString() } as Values<Data & { updatedAt: string }>)
+      .merge({ ...merged, updatedAt: moment().toISOString() } as Values<
+        Data & { updatedAt: string }
+      >)
       .output("after")) as (Data & { updatedAt: string }) | undefined;
 
-    const { updatedAt, ...rest } = (record ?? {}) as Record<string, unknown> & { updatedAt?: string };
-    const result = { ...(config.schema.parse(rest) as Data), updatedAt: updatedAt ?? null };
+    const { updatedAt, ...rest } = (record ?? {}) as Record<string, unknown> & {
+      updatedAt?: string;
+    };
+    const result = {
+      ...(config.schema.parse(rest) as Data),
+      updatedAt: updatedAt ?? null,
+    };
 
     await runAfterHooks("afterVarsUpdate", prefix, result);
 

package/src/core/worker.ts

@@ -45,7 +45,10 @@ export type WorkerReadyMessage = {
   type: "ready";
 };
 
-export type WorkerOutboundMessage = WorkerResponseMessage | WorkerErrorMessage | WorkerReadyMessage;
+export type WorkerOutboundMessage =
+  | WorkerResponseMessage
+  | WorkerErrorMessage
+  | WorkerReadyMessage;
 
 // Bounds how long shutdown waits for in-flight requests to finish before exiting anyway —
 // the supervisor can terminate a worker at any time, so this is a safety net, not the
@@ -54,14 +57,21 @@ const SHUTDOWN_DRAIN_TIMEOUT_MS = 10_000;
 const SHUTDOWN_POLL_INTERVAL_MS = 50;
 
 const isRequestMessage = (raw: unknown): raw is WorkerRequestMessage =>
-  typeof raw === "object" && raw !== null && (raw as { type?: unknown }).type === "request";
+  typeof raw === "object" &&
+  raw !== null &&
+  (raw as { type?: unknown }).type === "request";
 
 const isShutdownMessage = (raw: unknown): raw is WorkerShutdownMessage =>
-  typeof raw === "object" && raw !== null && (raw as { type?: unknown }).type === "shutdown";
+  typeof raw === "object" &&
+  raw !== null &&
+  (raw as { type?: unknown }).type === "shutdown";
 
 // Pure request/response conversion, split out from serveWorker()'s self/postMessage wiring
 // so it can be unit tested directly without spinning up a real Worker thread.
-export const buildResponseMessage = async (app: AnyElysia, msg: WorkerRequestMessage): Promise<WorkerResponseMessage> => {
+export const buildResponseMessage = async (
+  app: AnyElysia,
+  msg: WorkerRequestMessage,
+): Promise<WorkerResponseMessage> => {
   const request = new Request(msg.url, {
     method: msg.method,
     headers: msg.headers,
@@ -90,7 +100,9 @@ export const buildResponseMessage = async (app: AnyElysia, msg: WorkerRequestMes
 // real socket connections; app.handle() is the same Elysia entrypoint either way.
 export const serveWorker = (app: AnyElysia): void => {
   if (Bun.isMainThread) {
-    throw new Error('serveWorker() must run inside a Worker thread (new Worker("out/worker.js")), not the main thread.');
+    throw new Error(
+      'serveWorker() must run inside a Worker thread (new Worker("out/worker.js")), not the main thread.',
+    );
   }
 
   let inFlight = 0;
@@ -98,7 +110,11 @@ export const serveWorker = (app: AnyElysia): void => {
 
   const handleRequest = async (msg: WorkerRequestMessage): Promise<void> => {
     if (shuttingDown) {
-      self.postMessage({ type: "error", id: msg.id, message: "worker is shutting down" } satisfies WorkerErrorMessage);
+      self.postMessage({
+        type: "error",
+        id: msg.id,
+        message: "worker is shutting down",
+      } satisfies WorkerErrorMessage);
       return;
     }
 

package/src/models/file.ts

@@ -1,6 +1,6 @@
+import z from "zod";
 import { getConfig } from "../core/config";
 import { makeModel, numeric, text } from "../core/model";
-import z from "zod";
 
 const file = makeModel("file", {
   name: "File",

package/src/models/user.ts

@@ -1,5 +1,5 @@
-import { email, makeModel, text } from "../core/model";
 import z from "zod";
+import { email, makeModel, text } from "../core/model";
 
 const user = makeModel("user", {
   name: "Pengguna",

package/src/modules/admin.ts

@@ -1,8 +1,8 @@
+import { join } from "node:path";
+import Elysia from "elysia";
 import { getConfig } from "../core/config";
 import { makeModule } from "../core/module";
 import { resolveSafePath } from "../core/path_guard";
-import Elysia from "elysia";
-import { join } from "node:path";
 import elysia from "./elysia";
 
 // Lazy, not a top-level const — this file's static import runs before module.ts's own

package/src/modules/analytics.ts

@@ -1,9 +1,9 @@
-import { makeModule } from "../core/module";
 import Elysia from "elysia";
 import geoip from "geoip-lite";
 import moment from "moment";
 import { Table } from "surrealdb";
 import z from "zod";
+import { makeModule } from "../core/module";
 import auth from "./auth";
 import elysia from "./elysia";
 import logger from "./logger";
@@ -46,9 +46,27 @@ export const resolveClientIp = (
   return server?.requestIP(request)?.address ?? null;
 };
 
+// `request.url` reflects what the backend itself sees — behind a reverse proxy that
+// terminates TLS (the common case), that's `http://` even though visitors hit the site
+// over `https://`. That scheme mismatch alone breaks isSameOrigin's exact comparison,
+// so every internal navigation gets misclassified as an external referrer. Prefer the
+// headers a trusted proxy sets; fall back to request.url for direct connections.
+export const resolveRequestOrigin = (request: Request) => {
+  const forwardedHost = request.headers.get("x-forwarded-host");
+  if (forwardedHost) {
+    const proto =
+      request.headers.get("x-forwarded-proto")?.split(",")[0]!.trim() || "http";
+    return `${proto}://${forwardedHost.split(",")[0]!.trim()}`;
+  }
+
+  return new URL(request.url).origin;
+};
+
 const hashVisitor = (ip: string, userAgent: string) => {
   const today = moment().format("YYYY-MM-DD");
-  return new Bun.CryptoHasher("sha256").update(`${ip}:${userAgent}:${today}`).digest("hex");
+  return new Bun.CryptoHasher("sha256")
+    .update(`${ip}:${userAgent}:${today}`)
+    .digest("hex");
 };
 
 const lookupCountry = (ip: string | null) => {
@@ -87,22 +105,28 @@ const buildWhere = (from?: string, to?: string, path?: string) => {
 
 const analytics = makeModule(() => {
   const fn = () => ({
-    track: async ({ path, referrer, userAgent, ip, requestUrl }: TrackInput) => {
+    track: async ({
+      path,
+      referrer,
+      userAgent,
+      ip,
+      requestUrl,
+    }: TrackInput) => {
       try {
         const country = lookupCountry(ip);
         const visitorHash = ip && userAgent ? hashVisitor(ip, userAgent) : null;
-        const externalReferrer = isSameOrigin(referrer, requestUrl) ? null : referrer;
-
-        await surreal()
-          .create(table)
-          .content({
-            path,
-            referrer: externalReferrer,
-            userAgent,
-            country,
-            visitorHash,
-            createdAt: moment().toISOString(),
-          });
+        const externalReferrer = isSameOrigin(referrer, requestUrl)
+          ? null
+          : referrer;
+
+        await surreal().create(table).content({
+          path,
+          referrer: externalReferrer,
+          userAgent,
+          country,
+          visitorHash,
+          createdAt: moment().toISOString(),
+        });
       } catch (e) {
         logger().error(e, "[analytics] failed to track pageview");
       }
@@ -118,13 +142,14 @@ const analytics = makeModule(() => {
         "/summary",
         async ({ query: { from, to, path } }) => {
           const { where, params } = buildWhere(from, to, path);
-          const [rows] = await surreal().query<[{ visitorHash: string | null }[]]>(
-            `SELECT visitorHash FROM pageview ${where}`,
-            params,
-          );
+          const [rows] = await surreal().query<
+            [{ visitorHash: string | null }[]]
+          >(`SELECT visitorHash FROM pageview ${where}`, params);
 
           const totalPageviews = rows?.length ?? 0;
-          const uniqueVisitors = new Set((rows ?? []).map((r) => r.visitorHash).filter(Boolean)).size;
+          const uniqueVisitors = new Set(
+            (rows ?? []).map((r) => r.visitorHash).filter(Boolean),
+          ).size;
 
           return { data: { totalPageviews, uniqueVisitors } };
         },
@@ -134,7 +159,9 @@ const analytics = makeModule(() => {
         "/by-country",
         async ({ query: { from, to, path } }) => {
           const { where, params } = buildWhere(from, to, path);
-          const [rows] = await surreal().query<[{ country: string | null; count: number }[]]>(
+          const [rows] = await surreal().query<
+            [{ country: string | null; count: number }[]]
+          >(
             `SELECT country, count() AS count FROM pageview ${where} GROUP BY country ORDER BY count DESC`,
             params,
           );
@@ -147,7 +174,9 @@ const analytics = makeModule(() => {
         "/by-referrer",
         async ({ query: { from, to, path } }) => {
           const { where, params } = buildWhere(from, to, path);
-          const [rows] = await surreal().query<[{ referrer: string | null; count: number }[]]>(
+          const [rows] = await surreal().query<
+            [{ referrer: string | null; count: number }[]]
+          >(
             `SELECT referrer, count() AS count FROM pageview ${where} GROUP BY referrer ORDER BY count DESC`,
             params,
           );
@@ -160,7 +189,9 @@ const analytics = makeModule(() => {
         "/by-page",
         async ({ query: { from, to } }) => {
           const { where, params } = buildWhere(from, to, undefined);
-          const [rows] = await surreal().query<[{ path: string; count: number }[]]>(
+          const [rows] = await surreal().query<
+            [{ path: string; count: number }[]]
+          >(
             `SELECT path, count() AS count FROM pageview ${where} GROUP BY path ORDER BY count DESC`,
             params,
           );
@@ -178,7 +209,9 @@ const analytics = makeModule(() => {
           const { where, params } = buildWhere(from, to, path);
           const bucketLen = interval === "hour" ? 13 : 10; // "YYYY-MM-DDTHH" vs "YYYY-MM-DD"
 
-          const [rows] = await surreal().query<[{ date: string; count: number }[]]>(
+          const [rows] = await surreal().query<
+            [{ date: string; count: number }[]]
+          >(
             `SELECT string::slice(createdAt, 0, ${bucketLen}) AS date, count() AS count
              FROM pageview ${where}
              GROUP BY date
@@ -201,7 +234,9 @@ const analytics = makeModule(() => {
     return {
       // Runs after surreal's own spin() has connected — init() itself runs too early for DB queries.
       spin: async () => {
-        await surreal().query("DEFINE TABLE IF NOT EXISTS pageview SCHEMALESS;");
+        await surreal().query(
+          "DEFINE TABLE IF NOT EXISTS pageview SCHEMALESS;",
+        );
       },
     };
   };