Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import {
page,
pageComponent,
selectPageSchema,
} from "@openstatus/db/src/schema";
import { emitAudit } from "../audit";
import { requireScope } from "../auth";
import { type ServiceContext, withTransaction } from "../context";
import { LimitExceededError } from "../errors";
import { assertWithinLimit } from "../limits";
import type { Page } from "../types";
import {
assertAccessTypeAllowed,
assertCustomDomainAvailable,
assertSlugAvailable,
validateMonitorIdsActive,
} from "./internal";
import { CreatePageInput, NewPageInput } from "./schemas";
/** Full create — mirrors legacy `pageRouter.create` (insertPageSchema input). */
export async function createPage(args: {
ctx: ServiceContext;
input: CreatePageInput;
}): Promise<Page> {
const { ctx } = args;
requireScope(ctx, "write");
const input = CreatePageInput.parse(args.input);
if (input.customDomain && !ctx.workspace.limits["custom-domain"]) {
throw new LimitExceededError("custom-domain", 0);
}
if (input.customTheme && !ctx.workspace.limits["custom-theme"]) {
throw new LimitExceededError("custom-theme", 0);
}
if (
!ctx.workspace.limits.i18n &&
(input.defaultLocale !== "en" ||
input.locales?.some((locale) => locale !== "en"))
) {
throw new LimitExceededError("i18n", 0);
}
return withTransaction(ctx, async (tx) => {
await assertWithinLimit({
tx,
workspaceId: ctx.workspace.id,
limit: "status-pages",
});
await assertSlugAvailable({ tx, slug: input.slug });
await assertCustomDomainAvailable({ tx, customDomain: input.customDomain });
assertAccessTypeAllowed(ctx.workspace, {
accessType: input.accessType ?? "public",
passwordProtected: input.passwordProtected ?? null,
allowedIpRanges: input.allowedIpRanges ?? null,
allowIndex: input.allowIndex,
});
const {
monitors,
workspaceId: _ws,
id: _id,
configuration,
...pageProps
} = input;
const monitorIds = monitors?.map((m) => m.monitorId) ?? [];
const row = await tx
.insert(page)
.values({
workspaceId: ctx.workspace.id,
// `page.configuration` is a drizzle `text("…", { mode: "json" })`
// column — drizzle serialises objects automatically. Calling
// `JSON.stringify` first would double-encode and persist a raw
// JSON string, breaking downstream reads that expect an object.
configuration,
...pageProps,
authEmailDomains: pageProps.authEmailDomains?.join(","),
allowedIpRanges: pageProps.allowedIpRanges?.join(","),
})
.returning()
.get();
if (monitorIds.length > 0) {
const validMonitors = await validateMonitorIdsActive({
tx,
workspaceId: ctx.workspace.id,
monitorIds,
});
const monitorMap = new Map(validMonitors.map((m) => [m.id, m]));
const pageComponentValues = (monitors ?? [])
.map(({ monitorId }, index) => {
const m = monitorMap.get(monitorId);
if (!m || !m.workspaceId) return null;
return {
workspaceId: m.workspaceId,
pageId: row.id,
type: "monitor" as const,
monitorId,
name: m.externalName || m.name,
order: index,
groupId: null,
groupOrder: 0,
};
})
.filter((v): v is NonNullable<typeof v> => v !== null);
if (pageComponentValues.length > 0) {
await assertWithinLimit({
tx,
workspaceId: ctx.workspace.id,
limit: "page-components",
delta: pageComponentValues.length,
});
await tx.insert(pageComponent).values(pageComponentValues).run();
}
}
await emitAudit(tx, ctx, {
action: "page.create",
entityType: "page",
entityId: row.id,
after: row,
metadata: { slug: row.slug },
});
// `selectPageSchema.parse` normalises the drizzle row into the
// `Page` shape callers expect: `authEmailDomains` / `allowedIpRanges`
// go from the raw comma-joined string (drizzle-inferred) to the
// `string[]` the `selectPageSchema` defines. Previously this used
// `row as unknown as Page`, which hid the drift.
return selectPageSchema.parse(row);
});
}
/** Minimal create — matches the dashboard onboarding `new` shape. */
export async function newPage(args: {
ctx: ServiceContext;
input: NewPageInput;
}): Promise<Page> {
const { ctx } = args;
requireScope(ctx, "write");
const input = NewPageInput.parse(args.input);
return withTransaction(ctx, async (tx) => {
await assertWithinLimit({
tx,
workspaceId: ctx.workspace.id,
limit: "status-pages",
});
await assertSlugAvailable({ tx, slug: input.slug });
const defaultConfiguration = {
type: "absolute",
value: "requests",
uptime: true,
theme: "default-rounded",
};
const row = await tx
.insert(page)
.values({
workspaceId: ctx.workspace.id,
title: input.title,
slug: input.slug,
description: input.description ?? "",
icon: input.icon ?? "",
legacyPage: false,
configuration: defaultConfiguration,
customDomain: "",
allowIndex: true,
})
.returning()
.get();
await emitAudit(tx, ctx, {
action: "page.create",
entityType: "page",
entityId: row.id,
after: row,
metadata: { slug: row.slug, source: "new" },
});
// `selectPageSchema.parse` normalises the drizzle row into the
// `Page` shape callers expect: `authEmailDomains` / `allowedIpRanges`
// go from the raw comma-joined string (drizzle-inferred) to the
// `string[]` the `selectPageSchema` defines. Previously this used
// `row as unknown as Page`, which hid the drift.
return selectPageSchema.parse(row);
});
}