Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import { db as defaultDb, eq } from "@openstatus/db";
import { externalServiceComponent } from "@openstatus/db/src/schema";
import type { DB } from "../context";
import { withBusyRetry } from "../retry";
import { assignComponentSlugs } from "./internal";
export type UpsertExternalComponentInput = {
upstreamComponentId: string;
name: string;
description?: string;
groupName?: string;
position: number;
indicator: string;
status: string;
};
export type UpsertedComponent = {
id: number;
upstreamComponentId: string;
};
export type UpsertExternalComponentsResult = {
upserted: UpsertedComponent[];
};
type ExistingRow = {
id: number;
upstreamComponentId: string;
slug: string;
aliases: string[];
name: string;
description: string | null;
groupName: string | null;
position: number;
indicator: string;
status: string;
};
type DesiredRow = {
externalServiceId: number;
upstreamComponentId: string;
slug: string;
aliases: string[];
name: string;
description: string | null;
groupName: string | null;
position: number;
indicator: string;
status: string;
};
function nullish<T>(value: T | null | undefined): T | null {
return value ?? null;
}
function aliasesEqual(a: string[], b: string[]): boolean {
if (a === b) return true;
return JSON.stringify(a) === JSON.stringify(b);
}
function componentsEqual(existing: ExistingRow, desired: DesiredRow): boolean {
return (
existing.slug === desired.slug &&
existing.name === desired.name &&
nullish(existing.description) === nullish(desired.description) &&
nullish(existing.groupName) === nullish(desired.groupName) &&
existing.position === desired.position &&
existing.indicator === desired.indicator &&
existing.status === desired.status &&
aliasesEqual(existing.aliases, desired.aliases)
);
}
export async function upsertExternalComponentsForService(args: {
ctx?: { db?: DB };
externalServiceId: number;
components: UpsertExternalComponentInput[];
now?: Date;
}): Promise<UpsertExternalComponentsResult> {
const { ctx, externalServiceId, components } = args;
if (components.length === 0) return { upserted: [] };
const now = args.now ?? new Date();
const db = ctx?.db ?? defaultDb;
// No `withTransaction`/`emitAudit`: external services are a global, public,
// cron-driven catalogue with no workspace scope or audit log (ADR-0006/0007).
// `withBusyRetry` wraps the raw transaction since the audit-aware helper
// expects a workspace ServiceContext.
return withBusyRetry(() =>
db.transaction(async (tx) => {
const existing = await tx
.select({
id: externalServiceComponent.id,
upstreamComponentId: externalServiceComponent.upstreamComponentId,
slug: externalServiceComponent.slug,
aliases: externalServiceComponent.aliases,
name: externalServiceComponent.name,
description: externalServiceComponent.description,
groupName: externalServiceComponent.groupName,
position: externalServiceComponent.position,
indicator: externalServiceComponent.indicator,
status: externalServiceComponent.status,
})
.from(externalServiceComponent)
.where(
eq(externalServiceComponent.externalServiceId, externalServiceId),
)
.all();
const existingByUpstream = new Map<string, ExistingRow>(
existing.map((row) => [row.upstreamComponentId, row]),
);
const slugs = assignComponentSlugs({
existing,
incoming: components.map((c) => ({
upstreamComponentId: c.upstreamComponentId,
name: c.name,
})),
});
const inserts: DesiredRow[] = [];
const updates: Array<{ id: number; row: DesiredRow }> = [];
const upserted: UpsertedComponent[] = [];
for (const c of components) {
const assigned = slugs.get(c.upstreamComponentId);
const desired: DesiredRow = {
externalServiceId,
upstreamComponentId: c.upstreamComponentId,
slug: assigned?.slug ?? c.upstreamComponentId,
aliases: assigned?.aliases ?? [],
name: c.name,
description: nullish(c.description),
groupName: nullish(c.groupName),
position: c.position,
indicator: c.indicator,
status: c.status,
};
const prev = existingByUpstream.get(c.upstreamComponentId);
if (!prev) {
inserts.push(desired);
continue;
}
// skipped components still surface their existing id so the cron's TB
// publish can emit a snapshot for them every tick.
upserted.push({
id: prev.id,
upstreamComponentId: prev.upstreamComponentId,
});
if (!componentsEqual(prev, desired)) {
updates.push({ id: prev.id, row: desired });
}
}
if (inserts.length > 0) {
const insertedRows = await tx
.insert(externalServiceComponent)
.values(
inserts.map((row) => ({
...row,
firstSeenAt: now,
updatedAt: now,
})),
)
.returning({
id: externalServiceComponent.id,
upstreamComponentId: externalServiceComponent.upstreamComponentId,
})
.all();
for (const row of insertedRows) upserted.push(row);
}
for (const { id, row } of updates) {
await tx
.update(externalServiceComponent)
.set({
slug: row.slug,
aliases: row.aliases,
name: row.name,
description: row.description,
groupName: row.groupName,
position: row.position,
indicator: row.indicator,
status: row.status,
updatedAt: now,
})
.where(eq(externalServiceComponent.id, id))
.run();
}
return { upserted };
}),
);
}