Rallly is an open-source scheduling and collaboration tool designed to make organizing events and meetings easier.
TypeScript i18nextnext-authnextjspostgresqlprismareact-emailt3-stacktailwindcsstrpcturborepotypescriptzod
import "server-only";
import { createLogger } from "@rallly/logger";
import * as z from "zod";
import { env } from "@/env";
import { appVersion } from "@/lib/constants";
import { getMajorVersion, isOutdated } from "./utils";
const logger = createLogger("update-check");
const advisorySchema = z.object({
ghsaId: z.string(),
url: z.string(),
severity: z.enum(["low", "medium", "high", "critical"]).nullish(),
});
export type UpdateAdvisory = z.infer<typeof advisorySchema>;
const updateStatusSchema = z.object({
latest: z.string().nullish(),
url: z.string().nullish(),
publishedAt: z.string().nullish(),
security: z.boolean().nullish(),
advisories: z.array(advisorySchema).nullish(),
newMajor: z
.object({
version: z.string(),
migrationGuideUrl: z.string(),
security: z.boolean().nullish(),
advisories: z.array(advisorySchema).nullish(),
})
.nullish(),
});
export async function getUpdateStatus({ instanceId }: { instanceId: string }) {
if (!appVersion || !env.API_BASE_URL) return null;
const url = new URL("/api/updates", env.API_BASE_URL);
url.searchParams.set("version", appVersion);
url.searchParams.set("instanceId", instanceId);
try {
const res = await fetch(url, {
// Node fetch has no default timeout — without this a hung upstream
// holds the streamed slot open indefinitely on a cold cache
signal: AbortSignal.timeout(3000),
next: { revalidate: 3600 },
});
if (!res.ok) {
logger.warn(
{ instanceId, version: appVersion, status: res.status },
"Update check returned a non-success status",
);
return null;
}
const parsed = updateStatusSchema.safeParse(await res.json());
if (!parsed.success) {
logger.warn(
{ instanceId, version: appVersion, issues: parsed.error.issues },
"Update check returned an invalid response",
);
return null;
}
const currentMajor = getMajorVersion(appVersion);
const {
latest,
url: releaseUrl,
publishedAt,
security,
advisories,
newMajor,
} = parsed.data;
// The endpoint scopes `latest` to our own major. Guard anyway: a release
// from another major must never surface as a pullable update, and this
// code is frozen in fleet binaries.
const withinMajor =
latest &&
releaseUrl &&
publishedAt &&
currentMajor !== null &&
getMajorVersion(latest) === currentMajor &&
isOutdated(appVersion, latest)
? {
status: "update-available" as const,
latest,
url: releaseUrl,
publishedAt,
// Only meaningful alongside a pullable update; never let the
// flag alone raise an alarm
security: security === true,
advisories: security === true ? (advisories ?? []) : [],
}
: { status: "up-to-date" as const };
const newMajorVersion = newMajor ? getMajorVersion(newMajor.version) : null;
return {
...withinMajor,
newMajor:
newMajor &&
currentMajor !== null &&
newMajorVersion !== null &&
newMajorVersion > currentMajor
? {
major: newMajorVersion,
migrationGuideUrl: newMajor.migrationGuideUrl,
security: newMajor.security === true,
advisories:
newMajor.security === true ? (newMajor.advisories ?? []) : [],
}
: null,
};
} catch (error) {
logger.warn(
{ error, instanceId, version: appVersion },
"Failed to check for updates",
);
return null;
}
}