Status page

// src/standards/schema.ts
import {
  checkbox,
  date,
  defineSchemaSource,
  number,
  object,
  relation,
  text,
} from "@stndrds/client";

export const service = object({ name: "services", label: "Service" })
  .pluralLabel("Services")
  .icon("globe")
  .description("A URL the status page pings every five minutes.")
  .attribute(text({ name: "name", label: "Name" }).icon("globe").required())
  .attribute(text({ name: "url", label: "URL" }).url().icon("link").required())
  .attribute(number({ name: "expectedStatus", label: "Expected HTTP status" }).defaultValue(200))
  .attribute(number({ name: "position", label: "Position" }))
  .attribute(checkbox({ name: "enabled", label: "Enabled" }).defaultValue(true))
  .attribute(
    relation({ name: "incidents", label: "Incidents" })
      .to("incidents")
      .many()
      .bilateral({ object: "incidents", attribute: "services" })
  )
  .labelExpression("{{ name }}");

export const check = object({ name: "checks", label: "Check" })
  .pluralLabel("Checks")
  .description("One ping result. Written by the status page, kept for seven days.")
  .attribute(relation({ name: "service", label: "Service" }).to("services").required())
  .attribute(checkbox({ name: "ok", label: "OK" }))
  .attribute(number({ name: "statusCode", label: "HTTP status" }))
  .attribute(number({ name: "latencyMs", label: "Latency (ms)" }))
  .attribute(text({ name: "error", label: "Error" }))
  .attribute(date({ name: "checkedAt", label: "Checked at" }).includeTime().required())
  .labelExpression("{{ checkedAt }}");

export const dailyStat = object({ name: "daily-stats", label: "Daily stat" })
  .pluralLabel("Daily stats")
  .description("One row per service and UTC day, feeding the 90-day uptime bars.")
  .attribute(relation({ name: "service", label: "Service" }).to("services").required())
  .attribute(date({ name: "day", label: "Day" }).required())
  .attribute(number({ name: "total", label: "Checks" }))
  .attribute(number({ name: "failed", label: "Failed" }))
  .attribute(number({ name: "responded", label: "Responded" }))
  .attribute(number({ name: "avgLatencyMs", label: "Average latency (ms)" }))
  .labelExpression("{{ day }}");

// src/standards/schema.ts (end of file)
export const statusSource = defineSchemaSource("status", {
  objects: [service, check, dailyStat, incident, incidentUpdate],
  views,
});

// src/standards/sync-schema.ts
import {
  SchemaSourceConflictError,
  SchemaSourceValidationError,
  type Standards,
  StandardsAuthError,
} from "@stndrds/client";
import { statusSource } from "./schema";

/** Pushes the source; 0 on applied/unchanged, 1 on a conflict, a rejected definition or a refused key. */
export async function syncSchema(standards: Pick<Standards, "schema">): Promise<number> {
  try {
    const result = await standards.schema.sync(statusSource);
    log.info(result.applied ? "schema.applied" : "schema.unchanged", { hash: result.hash });
    return 0;
  } catch (error) {
    if (error instanceof SchemaSourceConflictError) {
      log.error("schema.conflict", { objectName: error.objectName, owner: error.owner });
      return 1;
    }
    if (error instanceof SchemaSourceValidationError || error instanceof StandardsAuthError) {
      log.error("schema.rejected", errorFields(error));
      return 1;
    }
    throw error;
  }
}

// scripts/sync-schema.ts
process.exitCode = await syncSchema(getStandards());

// src/check/run-checks.ts
export async function runChecks(deps: RunChecksDeps): Promise<RunChecksResult> {
  const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
  const checkedAt = deps.now();

  const services = await fetchAll(deps.standards.from(service).eq("enabled", true));

  const pings = await Promise.all(
    services.map(async (record) => ({
      record,
      result: await pingUrl(record.url, record.expectedStatus ?? 200, timeoutMs),
    }))
  );

  const writes = await Promise.allSettled(
    pings.map(({ record, result }) => recordCheck(deps.standards, record.id, result, checkedAt))
  );

  let writeErrors = writes.filter((w) => w.status === "rejected").length;
  let purged = 0;
  try {
    purged = await purgeOldChecks(deps.standards, daysAgo(checkedAt, RETENTION_DAYS));
  } catch (error) {
    writeErrors += 1;
  }

  const up = pings.filter((p) => p.result.ok).length;
  return { checked: pings.length, up, down: pings.length - up, writeErrors, purged };
}

// src/check/run-checks.ts
async function upsertDailyStat(
  standards: StandardsRecords,
  serviceId: string,
  result: PingResult,
  day: string
): Promise<void> {
  const stats = standards.from(dailyStat);
  const existing = await stats.eq("service", serviceId).eq("day", day).single();
  const responded = result.statusCode === null ? 0 : 1;
  if (!existing) {
    await stats.create({
      service: serviceId,
      day,
      total: 1,
      failed: result.ok ? 0 : 1,
      responded,
      ...(responded ? { avgLatencyMs: result.latencyMs } : {}),
    });
    return;
  }
  const previousResponded = existing.responded ?? 0;
  const previousAvg = existing.avgLatencyMs ?? 0;
  const nextResponded = previousResponded + responded;
  const avgLatencyMs = responded
    ? Math.round((previousAvg * previousResponded + result.latencyMs) / nextResponded)
    : previousAvg;
  await stats.update(existing.id, {
    total: (existing.total ?? 0) + 1,
    failed: (existing.failed ?? 0) + (result.ok ? 0 : 1),
    responded: nextResponded,
    ...(nextResponded === 0 ? {} : { avgLatencyMs }),
  });
}

// src/check/run-checks.ts
/** Raw checks older than this are purged; daily stats keep the history. */
const RETENTION_DAYS = 7;
/** One page per run: the API caps a list at 100 records, and the cron runs again in five minutes. */
const PURGE_BATCH = 100;

async function purgeOldChecks(standards: StandardsRecords, cutoff: Date): Promise<number> {
  const old = await standards
    .from(check)
    .lt("checkedAt", cutoff.toISOString())
    .limit(PURGE_BATCH)
    .fetch();
  for (const record of old.records) {
    await standards.from(check).delete(record.id);
  }
  return old.records.length;
}

// src/status/load-status.ts
import { cacheLife, cacheTag, revalidateTag } from "next/cache";

export const STATUS_CACHE_TAG = "status";

/** `expire: 0` expires the entry outright, so the first request after a run pays the rebuild rather than serving the previous generation. */
export function revalidateStatus(): void {
  revalidateTag(STATUS_CACHE_TAG, { expire: 0 });
}

/** Cached view of the whole page; the cron route revalidates the tag after each run. */
export async function loadStatusView(): Promise<StatusView> {
  "use cache";
  cacheLife({ stale: 60, revalidate: 60, expire: 600 });
  cacheTag(STATUS_CACHE_TAG);
  const now = new Date();
  const snapshot = await resolveStatus({
    fetchSnapshot: () => fetchSnapshot(getStandards(), now),
    store: getSnapshotStore(),
    now,
  });
  return deriveStatusView(snapshot, now);
}

// src/status/resolve-status.ts
/** The `reason` a degraded snapshot carries when the schema source was never synced to this workspace. */
export const SCHEMA_MISSING = "schema_missing";

export async function resolveStatus(deps: ResolveStatusDeps): Promise<StatusSnapshot> {
  try {
    return await deps.fetchSnapshot();
  } catch (error) {
    const reason = degradedReason(error);
    if (reason === null) throw error;
    log.warn("status.standards_unavailable", { reason, ...errorFields(error) });
    const last = reason === SCHEMA_MISSING ? null : await deps.store.load();
    if (last) return { ...last, availability: "stale", reason };
    return unavailableSnapshot(deps.now.toISOString(), reason);
  }
}