Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
services: feature gate, requireRole, slack-user mapping (#2790)
Thibault Le Ouay6024aa005b8a
diff --git a/apps/dashboard/src/hooks/use-feature.ts b/apps/dashboard/src/hooks/use-feature.tsindex ba6654a84..bb620ea4b 100644--- a/apps/dashboard/src/hooks/use-feature.ts+++ b/apps/dashboard/src/hooks/use-feature.ts@@ -1,19 +1,11 @@+import type { Feature } from "@openstatus/services";import { useQuery } from "@tanstack/react-query";import { useTRPC } from "@/lib/trpc/client";-/**- * Record<feature, [workspaceId, ...]>- */-const features = {- "slack-agent": [1, 6850],-};--export function useFeature(feature: keyof typeof features) {+export function useFeature(feature: Feature) {const trpc = useTRPC();const { data: workspace } = useQuery(trpc.workspace.get.queryOptions());- if (!workspace) return false;-- return features[feature]?.includes(workspace.id) ?? false;+ return workspace?.features.includes(feature) ?? false;}diff --git a/packages/api/src/router/workspace.ts b/packages/api/src/router/workspace.tsindex 7825dc170..585d6e1b3 100644--- a/packages/api/src/router/workspace.ts+++ b/packages/api/src/router/workspace.ts@@ -1,4 +1,5 @@import { Events } from "@openstatus/analytics";+import { enabledFeatures } from "@openstatus/services";import {getTrialDaysLeft,getWorkspaceUsage,@@ -17,6 +18,7 @@ export const workspaceRouter = createTRPCRouter({get: protectedProcedure.query(({ ctx }) => ({...ctx.workspace,trialDaysLeft: getTrialDaysLeft(ctx.workspace.trialEndsAt),+ features: enabledFeatures(ctx.workspace),})),usage: protectedProcedure.query(async ({ ctx }) => {diff --git a/packages/services/package.json b/packages/services/package.jsonindex f1848723c..483920fdb 100644--- a/packages/services/package.json+++ b/packages/services/package.json@@ -113,6 +113,10 @@"import": "./src/private-location/index.ts","types": "./src/private-location/index.ts"},+ "./slack-user": {+ "import": "./src/slack-user/index.ts",+ "types": "./src/slack-user/index.ts"+ },"./page-access": {"import": "./src/page-access/index.ts","types": "./src/page-access/index.ts"diff --git a/packages/services/src/__tests__/features.test.ts b/packages/services/src/__tests__/features.test.tsnew file mode 100644index 000000000..3bc17ba0d--- /dev/null+++ b/packages/services/src/__tests__/features.test.ts@@ -0,0 +1,44 @@+import { expect } from "@std/expect";+import { describe, test } from "@std/testing/bdd";++import { ForbiddenError } from "../errors";+import { isFeatureEnabled, requireFeature } from "../features";+import type { Workspace } from "../types";++const none = new Set<string>();++describe("isFeatureEnabled", () => {+ test("allowlisted workspace", () => {+ expect(isFeatureEnabled({ id: 1 }, "incident-management", none)).toBe(true);+ });++ test("other workspace", () => {+ expect(+ isFeatureEnabled({ id: 987654321 }, "incident-management", none),+ ).toBe(false);+ });++ test("env override enables it for every workspace", () => {+ expect(+ isFeatureEnabled(+ { id: 987654321 },+ "incident-management",+ new Set(["incident-management"]),+ ),+ ).toBe(true);+ });+});++describe("requireFeature", () => {+ test("throws ForbiddenError when disabled", () => {+ const processEnv: Record<string, string | undefined> = process.env;+ if (processEnv.OPENSTATUS_FEATURES?.includes("slack-agent")) return;+ const workspace = { id: 987654321 } as Workspace;+ expect(() =>+ requireFeature(+ { workspace, actor: { type: "system", job: "test" } },+ "slack-agent",+ ),+ ).toThrow(ForbiddenError);+ });+});diff --git a/packages/services/src/auth/__tests__/require-role.test.ts b/packages/services/src/auth/__tests__/require-role.test.tsnew file mode 100644index 000000000..a18621a5c--- /dev/null+++ b/packages/services/src/auth/__tests__/require-role.test.ts@@ -0,0 +1,97 @@+import { db } from "@openstatus/db";+import {+ addUserToWorkspace,+ createUser,+} from "@openstatus/db/src/test/factories";+import { expect } from "@std/expect";+import { beforeAll, describe, test } from "@std/testing/bdd";++import {+ createWorkspaceFixture,+ makeApiKeyCtx,+ makeSlackCtx,+ makeSystemCtx,+ makeUserCtx,+} from "../../../test/helpers";+import { ForbiddenError } from "../../errors";+import type { Workspace } from "../../types";+import { requireRole } from "../require-role";++let workspace: Workspace;+let ownerId: number;+let adminId: number;+let memberId: number;+let outsiderId: number;++beforeAll(async () => {+ const fixture = await createWorkspaceFixture("team");+ workspace = fixture.workspace;+ ownerId = fixture.userId;+ adminId = (await createUser()).id;+ memberId = (await createUser()).id;+ outsiderId = (await createUser()).id;+ await addUserToWorkspace(adminId, workspace.id, "admin");+ await addUserToWorkspace(memberId, workspace.id, "member");+});++describe("requireRole", () => {+ test("user with an allowed role passes", async () => {+ await requireRole(db, makeUserCtx(workspace, { userId: ownerId }), [+ "owner",+ "admin",+ ]);+ await requireRole(db, makeUserCtx(workspace, { userId: adminId }), [+ "owner",+ "admin",+ ]);+ });++ test("member is rejected from an admin-only check", async () => {+ await expect(+ requireRole(db, makeUserCtx(workspace, { userId: memberId }), [+ "owner",+ "admin",+ ]),+ ).rejects.toThrow(ForbiddenError);+ });++ test("orUserId lets the named user through", async () => {+ await requireRole(+ db,+ makeUserCtx(workspace, { userId: memberId }),+ ["owner", "admin"],+ { orUserId: memberId },+ );+ });++ test("non-member is rejected even from member-level checks", async () => {+ await expect(+ requireRole(db, makeUserCtx(workspace, { userId: outsiderId }), [+ "owner",+ "admin",+ "member",+ ]),+ ).rejects.toThrow(ForbiddenError);+ });++ test("slack actor resolves through its linked user", async () => {+ const ctx = makeSlackCtx(workspace, {+ teamId: "T1",+ slackUserId: "U1",+ userId: adminId,+ });+ await requireRole(db, ctx, ["owner", "admin"]);+ });++ test("api key without a user passes member-level only", async () => {+ const ctx = makeApiKeyCtx(workspace, { keyId: "k1" });+ await requireRole(db, ctx, ["owner", "admin", "member"]);+ await expect(requireRole(db, ctx, ["owner", "admin"])).rejects.toThrow(+ ForbiddenError,+ );+ });++ test("system always passes", async () => {+ await requireRole(db, makeSystemCtx(workspace, { job: "test" }), ["owner"]);+ });+});diff --git a/packages/services/src/auth/index.ts b/packages/services/src/auth/index.tsindex 45388ded2..08ad5e795 100644--- a/packages/services/src/auth/index.ts+++ b/packages/services/src/auth/index.ts@@ -1,2 +1,3 @@export { matchesScope } from "./matches-scope";+export { requireRole } from "./require-role";export { requireScope } from "./require-scope";diff --git a/packages/services/src/auth/require-role.ts b/packages/services/src/auth/require-role.tsnew file mode 100644index 000000000..f00dfe88d--- /dev/null+++ b/packages/services/src/auth/require-role.ts@@ -0,0 +1,36 @@+import type { WorkspaceRole } from "@openstatus/db/src/schema";++import { type DB, type ServiceContext, tryGetActorUserId } from "../context";+import { ForbiddenError } from "../errors";+import { getMembership } from "../member/membership";++/**+ * Assert the actor's workspace role is one of `roles`, or that the actor is+ * `orUserId`. `system` always passes; key-based actors without a linked user+ * pass only member-level checks.+ */+export async function requireRole(+ db: DB,+ ctx: ServiceContext,+ roles: ReadonlyArray<WorkspaceRole>,+ opts: { orUserId?: number | null } = {},+): Promise<void> {+ const { actor } = ctx;+ if (actor.type === "system") return;++ const userId = tryGetActorUserId(actor);+ if (userId !== null) {+ if (opts.orUserId != null && opts.orUserId === userId) return;+ const membership = await getMembership(db, userId, ctx.workspace.id);+ if (membership && roles.includes(membership.role)) return;+ throw new ForbiddenError(`Requires one of the roles: ${roles.join(", ")}`);+ }++ if (+ (actor.type === "apiKey" || actor.type === "mcp") &&+ roles.includes("member")+ ) {+ return;+ }+ throw new ForbiddenError(`Requires one of the roles: ${roles.join(", ")}`);+}diff --git a/packages/services/src/features.ts b/packages/services/src/features.tsnew file mode 100644index 000000000..4652118b3--- /dev/null+++ b/packages/services/src/features.ts@@ -0,0 +1,45 @@+import type { ServiceContext } from "./context";+import { ForbiddenError } from "./errors";+import type { Workspace } from "./types";++const featureWorkspaces = {+ "slack-agent": [1, 6850],+ "incident-management": [1, 6850],+} satisfies Record<string, ReadonlyArray<number>>;++export type Feature = keyof typeof featureWorkspaces;++export const FEATURES = Object.keys(featureWorkspaces) as Feature[];++// `OPENSTATUS_FEATURES` (comma list) turns a feature on for every workspace:+// local dev, self-hosting and test runs.+function featuresFromEnv(): Set<string> {+ const processEnv: Record<string, string | undefined> = process.env;+ const raw = processEnv.OPENSTATUS_FEATURES ?? "";+ return new Set(+ raw+ .split(",")+ .map((f) => f.trim())+ .filter(Boolean),+ );+}++export function isFeatureEnabled(+ workspace: Pick<Workspace, "id">,+ feature: Feature,+ envFeatures: Set<string> = featuresFromEnv(),+): boolean {+ const ids: ReadonlyArray<number> = featureWorkspaces[feature];+ return ids.includes(workspace.id) || envFeatures.has(feature);+}++export function enabledFeatures(workspace: Pick<Workspace, "id">): Feature[] {+ const envFeatures = featuresFromEnv();+ return FEATURES.filter((f) => isFeatureEnabled(workspace, f, envFeatures));+}++export function requireFeature(ctx: ServiceContext, feature: Feature): void {+ if (!isFeatureEnabled(ctx.workspace, feature)) {+ throw new ForbiddenError(`Feature not enabled: ${feature}`);+ }+}diff --git a/packages/services/src/index.ts b/packages/services/src/index.tsindex fa50b9f7e..afe6989b0 100644--- a/packages/services/src/index.ts+++ b/packages/services/src/index.ts@@ -42,7 +42,15 @@ export {emitAudit,} from "./audit";-export { matchesScope, requireScope } from "./auth";+export { matchesScope, requireRole, requireScope } from "./auth";++export {+ enabledFeatures,+ FEATURES,+ type Feature,+ isFeatureEnabled,+ requireFeature,+} from "./features";export {LIMIT_KEYS,diff --git a/packages/services/src/slack-user/__tests__/slack-user.test.ts b/packages/services/src/slack-user/__tests__/slack-user.test.tsnew file mode 100644index 000000000..9c781fbf0--- /dev/null+++ b/packages/services/src/slack-user/__tests__/slack-user.test.ts@@ -0,0 +1,148 @@+import { eq } from "@openstatus/db";+import { user } from "@openstatus/db/src/schema";+import {+ addUserToWorkspace,+ createUser,+} from "@openstatus/db/src/test/factories";+import { expect } from "@std/expect";+import { beforeAll, describe, test } from "@std/testing/bdd";++import {+ createWorkspaceFixture,+ expectAuditRow,+ makeSystemCtx,+ makeUserCtx,+ withTestTransaction,+} from "../../../test/helpers";+import { ForbiddenError } from "../../errors";+import type { Workspace } from "../../types";+import {+ createSlackUserMapping,+ deleteSlackUserMappings,+ getSlackUserMapping,+} from "../index";++let workspace: Workspace;+let memberId: number;++beforeAll(async () => {+ const fixture = await createWorkspaceFixture("team");+ workspace = fixture.workspace;+ memberId = (await createUser()).id;+ await addUserToWorkspace(memberId, workspace.id, "member");+});++describe("slack user mapping", () => {+ test("create + get round-trip, audited", async () => {+ await withTestTransaction(async (tx) => {+ const ctx = { ...makeSystemCtx(workspace, { job: "test" }), db: tx };+ const row = await createSlackUserMapping({+ ctx,+ input: { teamId: "T1", slackUserId: "U1", userId: memberId },+ });+ expect(+ await getSlackUserMapping({+ ctx,+ input: { teamId: "T1", slackUserId: "U1" },+ }),+ ).toBe(memberId);+ await expectAuditRow({+ workspaceId: workspace.id,+ action: "slack_user.create",+ entityType: "slack_user",+ entityId: row.id,+ actorType: "system",+ db: tx,+ });+ });+ });++ test("re-linking to another member replaces the row", async () => {+ const other = await createUser();+ await addUserToWorkspace(other.id, workspace.id, "member");+ await withTestTransaction(async (tx) => {+ const ctx = { ...makeSystemCtx(workspace, { job: "test" }), db: tx };+ const first = await createSlackUserMapping({+ ctx,+ input: { teamId: "T2", slackUserId: "U2", userId: memberId },+ });+ await createSlackUserMapping({+ ctx,+ input: { teamId: "T2", slackUserId: "U2", userId: other.id },+ });+ expect(+ await getSlackUserMapping({+ ctx,+ input: { teamId: "T2", slackUserId: "U2" },+ }),+ ).toBe(other.id);+ await expectAuditRow({+ workspaceId: workspace.id,+ action: "slack_user.delete",+ entityType: "slack_user",+ entityId: first.id,+ db: tx,+ });+ });+ });++ test("rejects a user who is not a member", async () => {+ const outsider = await createUser();+ await withTestTransaction(async (tx) => {+ const ctx = {+ ...makeUserCtx(workspace, { userId: outsider.id }),+ db: tx,+ };+ await expect(+ createSlackUserMapping({+ ctx,+ input: { teamId: "T3", slackUserId: "U3", userId: outsider.id },+ }),+ ).rejects.toThrow(ForbiddenError);+ });+ });++ test("a deleted user no longer resolves", async () => {+ const gone = await createUser();+ await addUserToWorkspace(gone.id, workspace.id, "member");+ await withTestTransaction(async (tx) => {+ const ctx = { ...makeSystemCtx(workspace, { job: "test" }), db: tx };+ await createSlackUserMapping({+ ctx,+ input: { teamId: "T4", slackUserId: "U4", userId: gone.id },+ });+ await tx+ .update(user)+ .set({ deletedAt: new Date() })+ .where(eq(user.id, gone.id));+ expect(+ await getSlackUserMapping({+ ctx,+ input: { teamId: "T4", slackUserId: "U4" },+ }),+ ).toBeNull();+ });+ });++ test("deleteSlackUserMappings by user removes and audits each row", async () => {+ await withTestTransaction(async (tx) => {+ const ctx = { ...makeSystemCtx(workspace, { job: "test" }), db: tx };+ await createSlackUserMapping({+ ctx,+ input: { teamId: "T5", slackUserId: "U5", userId: memberId },+ });+ const count = await deleteSlackUserMappings({+ tx,+ ctx,+ where: { userId: memberId },+ });+ expect(count).toBeGreaterThanOrEqual(1);+ expect(+ await getSlackUserMapping({+ ctx,+ input: { teamId: "T5", slackUserId: "U5" },+ }),+ ).toBeNull();+ });+ });+});diff --git a/packages/services/src/slack-user/create.ts b/packages/services/src/slack-user/create.tsnew file mode 100644index 000000000..b39a5e0e4--- /dev/null+++ b/packages/services/src/slack-user/create.ts@@ -0,0 +1,62 @@+import { and, eq } from "@openstatus/db";+import { type SlackUser, slackUser } from "@openstatus/db/src/schema";++import { emitAudit } from "../audit";+import { requireScope } from "../auth";+import { type ServiceContext, withTransaction } from "../context";+import { ForbiddenError } from "../errors";+import { getMembership } from "../member/membership";+import { deleteSlackUserMappings } from "./internal";+import { CreateSlackUserMappingInput } from "./schemas";++/** Link a Slack user to a workspace member; re-linking replaces the old row. */+export async function createSlackUserMapping(args: {+ ctx: ServiceContext;+ input: CreateSlackUserMappingInput;+}): Promise<SlackUser> {+ const { ctx } = args;+ requireScope(ctx, "write");+ const input = CreateSlackUserMappingInput.parse(args.input);++ return withTransaction(ctx, async (tx) => {+ const membership = await getMembership(tx, input.userId, ctx.workspace.id);+ if (!membership) {+ throw new ForbiddenError("User is not a member of this workspace");+ }++ const existing = await tx+ .select()+ .from(slackUser)+ .where(+ and(+ eq(slackUser.workspaceId, ctx.workspace.id),+ eq(slackUser.slackTeamId, input.teamId),+ eq(slackUser.slackUserId, input.slackUserId),+ ),+ )+ .get();+ if (existing?.userId === input.userId) return existing;+ if (existing) {+ await deleteSlackUserMappings({ tx, ctx, where: { id: existing.id } });+ }++ const record = await tx+ .insert(slackUser)+ .values({+ workspaceId: ctx.workspace.id,+ slackTeamId: input.teamId,+ slackUserId: input.slackUserId,+ userId: input.userId,+ })+ .returning()+ .get();++ await emitAudit(tx, ctx, {+ action: "slack_user.create",+ entityType: "slack_user",+ entityId: record.id,+ after: record,+ });+ return record;+ });+}diff --git a/packages/services/src/slack-user/get.ts b/packages/services/src/slack-user/get.tsnew file mode 100644index 000000000..c8963c85f--- /dev/null+++ b/packages/services/src/slack-user/get.ts@@ -0,0 +1,37 @@+import { and, eq, isNull } from "@openstatus/db";+import { slackUser, user, usersToWorkspaces } from "@openstatus/db/src/schema";++import { type ServiceContext, getReadDb } from "../context";+import { GetSlackUserMappingInput } from "./schemas";++/**+ * The openstatus user a Slack user is linked to, or `null`. Only a current,+ * non-deleted member of the workspace counts, so a stale row never authorizes.+ */+export async function getSlackUserMapping(args: {+ ctx: ServiceContext;+ input: GetSlackUserMappingInput;+}): Promise<number | null> {+ const input = GetSlackUserMappingInput.parse(args.input);+ const row = await getReadDb(args.ctx)+ .select({ userId: slackUser.userId })+ .from(slackUser)+ .innerJoin(+ usersToWorkspaces,+ and(+ eq(usersToWorkspaces.userId, slackUser.userId),+ eq(usersToWorkspaces.workspaceId, slackUser.workspaceId),+ ),+ )+ .innerJoin(user, eq(user.id, slackUser.userId))+ .where(+ and(+ eq(slackUser.workspaceId, args.ctx.workspace.id),+ eq(slackUser.slackTeamId, input.teamId),+ eq(slackUser.slackUserId, input.slackUserId),+ isNull(user.deletedAt),+ ),+ )+ .get();+ return row?.userId ?? null;+}diff --git a/packages/services/src/slack-user/index.ts b/packages/services/src/slack-user/index.tsnew file mode 100644index 000000000..e83b422e7--- /dev/null+++ b/packages/services/src/slack-user/index.ts@@ -0,0 +1,7 @@+export { createSlackUserMapping } from "./create";+export { getSlackUserMapping } from "./get";+export { deleteSlackUserMappings } from "./internal";+export {+ CreateSlackUserMappingInput,+ GetSlackUserMappingInput,+} from "./schemas";diff --git a/packages/services/src/slack-user/internal.ts b/packages/services/src/slack-user/internal.tsnew file mode 100644index 000000000..5fe37d48d--- /dev/null+++ b/packages/services/src/slack-user/internal.ts@@ -0,0 +1,35 @@+import { and, eq } from "@openstatus/db";+import { slackUser } from "@openstatus/db/src/schema";++import { emitAudit } from "../audit";+import type { DB, ServiceContext } from "../context";++export async function deleteSlackUserMappings(args: {+ tx: DB;+ ctx: ServiceContext;+ where: { userId: number } | { slackTeamId: string } | { id: number };+}): Promise<number> {+ const { tx, ctx, where } = args;+ const filter =+ "userId" in where+ ? eq(slackUser.userId, where.userId)+ : "slackTeamId" in where+ ? eq(slackUser.slackTeamId, where.slackTeamId)+ : eq(slackUser.id, where.id);++ const removed = await tx+ .delete(slackUser)+ .where(and(eq(slackUser.workspaceId, ctx.workspace.id), filter))+ .returning();++ for (const row of removed) {+ await emitAudit(tx, ctx, {+ action: "slack_user.delete",+ entityType: "slack_user",+ entityId: row.id,+ before: row,+ metadata: { slackTeamId: row.slackTeamId, userId: row.userId },+ });+ }+ return removed.length;+}diff --git a/packages/services/src/slack-user/schemas.ts b/packages/services/src/slack-user/schemas.tsnew file mode 100644index 000000000..e870947bb--- /dev/null+++ b/packages/services/src/slack-user/schemas.ts@@ -0,0 +1,14 @@+import { z } from "zod";++export const GetSlackUserMappingInput = z.object({+ teamId: z.string().min(1),+ slackUserId: z.string().min(1),+});+export type GetSlackUserMappingInput = z.infer<typeof GetSlackUserMappingInput>;++export const CreateSlackUserMappingInput = GetSlackUserMappingInput.extend({+ userId: z.number().int(),+});+export type CreateSlackUserMappingInput = z.infer<+ typeof CreateSlackUserMappingInput+>;