Skip to content

Open-source status page, incident response and uptime monitoring

feat: slack rich text notes (#2835)

Maximilian Kaskeea25dca7f460
diff --git a/apps/dashboard/src/components/content/process-message.tsx b/apps/dashboard/src/components/content/process-message.tsx
index 791a1f8e9..23deb35e4 100644
--- a/apps/dashboard/src/components/content/process-message.tsx
+++ b/apps/dashboard/src/components/content/process-message.tsx
@@ -2,6 +2,7 @@ import type { AnchorHTMLAttributes } from "react";
import { Fragment, createElement } from "react";
import { jsx, jsxs } from "react/jsx-runtime";
import rehypeReact from "rehype-react";
+import remarkGfm from "remark-gfm";
import remarkParse from "remark-parse";
import remarkRehype from "remark-rehype";
import { unified } from "unified";
@@ -9,6 +10,7 @@ import { unified } from "unified";
export function ProcessMessage({ value }: { value: string }) {
const result = unified()
.use(remarkParse)
+ .use(remarkGfm)
.use(remarkRehype)
.use(rehypeReact, {
createElement,
diff --git a/apps/server/src/libs/test/doubles/slack-test-state.ts b/apps/server/src/libs/test/doubles/slack-test-state.ts
index 4698fddb5..7519e052c 100644
--- a/apps/server/src/libs/test/doubles/slack-test-state.ts
+++ b/apps/server/src/libs/test/doubles/slack-test-state.ts
@@ -26,6 +26,8 @@ export interface SlackTestState {
usersInfoImpl: (args: Record<string, unknown>) => Promise<unknown>;
/** `reactions.get` result; the default message has no reactions. */
reactionsGetImpl: (args: Record<string, unknown>) => Promise<unknown>;
+ /** `conversations.info` result; the default channel has no name. */
+ conversationsInfoImpl: (args: Record<string, unknown>) => Promise<unknown>;
}
const g = globalThis as Record<string, unknown>;
@@ -52,6 +54,7 @@ if (!g.__slackTestState) {
}),
usersInfoImpl: () => Promise.resolve({ ok: true, user: { profile: {} } }),
reactionsGetImpl: () => Promise.resolve({ ok: true, message: {} }),
+ conversationsInfoImpl: () => Promise.resolve({ ok: true, channel: {} }),
} satisfies SlackTestState;
}
diff --git a/apps/server/src/libs/test/doubles/slack-web-api.mock.ts b/apps/server/src/libs/test/doubles/slack-web-api.mock.ts
index 01a73fc12..dc301130a 100644
--- a/apps/server/src/libs/test/doubles/slack-web-api.mock.ts
+++ b/apps/server/src/libs/test/doubles/slack-web-api.mock.ts
@@ -81,6 +81,10 @@ export class WebClient {
s.calls.push({ method: "conversations.history", args });
return s.historyImpl();
},
+ info: (args: Record<string, unknown>) => {
+ s.calls.push({ method: "conversations.info", args });
+ return s.conversationsInfoImpl(args);
+ },
};
agents = {
sessions: {
diff --git a/apps/server/src/routes/slack/handler.test.ts b/apps/server/src/routes/slack/handler.test.ts
index 425aab02e..8b8cd958e 100644
--- a/apps/server/src/routes/slack/handler.test.ts
+++ b/apps/server/src/routes/slack/handler.test.ts
@@ -2043,6 +2043,8 @@ describe("incident channel events", () => {
resetSlackTestState();
slackTestState.reactionsGetImpl = () =>
Promise.resolve({ ok: true, message: {} });
+ slackTestState.conversationsInfoImpl = () =>
+ Promise.resolve({ ok: true, channel: {} });
channelId = `C_PIN_${crypto.randomUUID()}`;
const [row] = await db
.insert(incident)
@@ -2101,6 +2103,165 @@ describe("incident channel events", () => {
expect(rows[0].message).toContain("https://slack.test/archives/");
});
+ test("rich_text wins over mrkdwn: emoji, styles, mentions and channels", async () => {
+ // U1 is the pinner and must stay linked; U9 has no email, so the
+ // profile name is the only thing we know about them.
+ slackTestState.usersInfoImpl = (args) =>
+ Promise.resolve(
+ args.user === "U9"
+ ? { ok: true, user: { real_name: "Jane Doe", profile: {} } }
+ : { ok: true, user: { profile: { email: "[email protected]" } } },
+ );
+ slackTestState.conversationsInfoImpl = () =>
+ Promise.resolve({ ok: true, channel: { name: "inc-db" } });
+ slackTestState.historyImpl = () =>
+ Promise.resolve({
+ messages: [
+ {
+ ts: "503.1",
+ user: "U2",
+ text: "*rolled back* :face_holding_back_tears: <@U9> see <#C7|inc-db>",
+ blocks: [
+ {
+ type: "rich_text",
+ elements: [
+ {
+ type: "rich_text_section",
+ elements: [
+ {
+ type: "text",
+ text: "rolled back",
+ style: { bold: true },
+ },
+ { type: "text", text: " " },
+ {
+ type: "emoji",
+ name: "face_holding_back_tears",
+ unicode: "1f979",
+ },
+ { type: "text", text: " " },
+ { type: "user", user_id: "U9" },
+ { type: "text", text: " see " },
+ { type: "channel", channel_id: "C7" },
+ ],
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ });
+ await pin("503.1");
+ await waitForCall("reactions.add");
+ const rows = await notes();
+ expect(rows).toHaveLength(1);
+ expect(rows[0].message).toContain(
+ "**rolled back** 🥹 @Jane Doe see #inc-db",
+ );
+ expect(rows[0].message).not.toContain(":face_holding_back_tears:");
+ });
+
+ test("a mention whose lookup fails keeps the raw id", async () => {
+ slackTestState.usersInfoImpl = (args) =>
+ args.user === "U9"
+ ? Promise.reject(new Error("user_not_found"))
+ : Promise.resolve({
+ ok: true,
+ user: { profile: { email: "[email protected]" } },
+ });
+ slackTestState.historyImpl = () =>
+ Promise.resolve({
+ messages: [
+ {
+ ts: "504.1",
+ text: "<@U9> ack",
+ blocks: [
+ {
+ type: "rich_text",
+ elements: [
+ {
+ type: "rich_text_section",
+ elements: [
+ { type: "user", user_id: "U9" },
+ { type: "text", text: " ack" },
+ ],
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ });
+ await pin("504.1");
+ await waitForCall("reactions.add");
+ const rows = await notes();
+ expect(rows).toHaveLength(1);
+ expect(rows[0].message).toContain("@U9 ack");
+ });
+
+ test("the note keeps the time the message was said", async () => {
+ const saidAt = Math.floor(Date.now() / 1000) - 3600;
+ const ts = `${saidAt}.000100`;
+ slackTestState.historyImpl = () =>
+ Promise.resolve({ messages: [{ ts, text: "an hour ago" }] });
+ await pin(ts);
+ await waitForCall("reactions.add");
+ const rows = await notes();
+ expect(rows).toHaveLength(1);
+ expect(Math.abs(rows[0].createdAt.getTime() - saidAt * 1000)).toBeLessThan(
+ 1000,
+ );
+ });
+
+ test("a message with only attachments is noted from their fallback", async () => {
+ slackTestState.historyImpl = () =>
+ Promise.resolve({
+ messages: [
+ {
+ ts: "505.1",
+ text: "",
+ attachments: [{ fallback: "[FIRING] db latency > 2s" }],
+ },
+ ],
+ });
+ await pin("505.1");
+ await waitForCall("reactions.add");
+ const rows = await notes();
+ expect(rows).toHaveLength(1);
+ expect(rows[0].message).toContain("[FIRING] db latency > 2s");
+ });
+
+ test("an attachment with an empty fallback is noted from its text", async () => {
+ slackTestState.historyImpl = () =>
+ Promise.resolve({
+ messages: [
+ {
+ ts: "507.1",
+ text: "",
+ attachments: [{ fallback: "", text: "Deploy 1234 failed" }],
+ },
+ ],
+ });
+ await pin("507.1");
+ await waitForCall("reactions.add");
+ const rows = await notes();
+ expect(rows).toHaveLength(1);
+ expect(rows[0].message).toContain("Deploy 1234 failed");
+ });
+
+ test("a message with nothing to copy tells the pinner", async () => {
+ slackTestState.historyImpl = () =>
+ Promise.resolve({ messages: [{ ts: "506.1", text: "" }] });
+ await pin("506.1");
+ const ephemeral = await waitForCall("postEphemeral");
+ expect(ephemeral?.args.text).toContain("Nothing to copy");
+ await new Promise((r) => setTimeout(r, 50));
+ expect(slackTestState.calls.some((c) => c.method === "reactions.add")).toBe(
+ false,
+ );
+ expect(await notes()).toHaveLength(0);
+ });
+
test("a message already confirmed is not noted twice", async () => {
slackTestState.historyImpl = () =>
Promise.resolve({ messages: [{ ts: "501.1", text: "Twice" }] });
diff --git a/apps/server/src/routes/slack/incident-events.ts b/apps/server/src/routes/slack/incident-events.ts
index bbf612501..a7467407d 100644
--- a/apps/server/src/routes/slack/incident-events.ts
+++ b/apps/server/src/routes/slack/incident-events.ts
@@ -3,6 +3,7 @@ import type { ServiceContext } from "@openstatus/services";
import {
addIncidentNote,
getIncidentBySlackChannel,
+ isAllowedNoteCreatedAt,
unbindIncidentSlackChannel,
} from "@openstatus/services/incident";
import { WebClient } from "@slack/web-api";
@@ -17,6 +18,12 @@ import {
requireSlackMember,
slackAgentAllowed,
} from "./require-slack-member";
+import { resolveSlackMentionNames } from "./resolve-slack-user";
+import {
+ collectMentions,
+ mentionLabelsFromText,
+ richTextToMarkdown,
+} from "./rich-text";
import type { SlackWorkspace } from "./workspace-resolver";
const logger = getLogger(["api-server", "slack", "incident-events"]);
@@ -24,7 +31,67 @@ const logger = getLogger(["api-server", "slack", "incident-events"]);
const PIN = "pushpin";
const DONE = "white_check_mark";
-type SlackMessage = { ts?: string; text?: string; user?: string };
+type SlackMessage = {
+ ts?: string;
+ text?: string;
+ user?: string;
+ blocks?: unknown[];
+ attachments?: { text?: string; fallback?: string }[];
+};
+
+const NOTHING_TO_COPY = "Nothing to copy from that message.";
+const VERB_LAG_MS = 60_000;
+
+/**
+ * A Slack `ts` ("1759300000.123456") as the time the message was said, or
+ * `undefined` (now) when the verb would reject it as outside its window.
+ */
+function messageDate(ts: string): Date | undefined {
+ const date = new Date(Number(ts) * 1000);
+ const now = Date.now();
+ // The verb samples its own `now` a moment later; a boundary message must
+ // pass both, or the pin would fail instead of falling back to now.
+ return isAllowedNoteCreatedAt(date, now) &&
+ isAllowedNoteCreatedAt(date, now + VERB_LAG_MS)
+ ? date
+ : undefined;
+}
+
+/** Alert bots post `attachments` with an empty `text`. */
+function attachmentsText(message: SlackMessage): string {
+ return (message.attachments ?? [])
+ .map((a) => a.fallback?.trim() || a.text?.trim() || "")
+ .filter(Boolean)
+ .join("\n\n");
+}
+
+async function noteBody(args: {
+ resolved: SlackWorkspace;
+ teamId: string;
+ slack: WebClient;
+ message: SlackMessage;
+}): Promise<string> {
+ const { resolved, teamId, slack, message } = args;
+ const labels = mentionLabelsFromText(message.text);
+ const lookedUp = await resolveSlackMentionNames({
+ workspace: resolved.workspace,
+ teamId,
+ slack,
+ ...collectMentions(message.blocks),
+ });
+ // A looked-up name beats the label Slack put in `text`.
+ const names = {
+ users: new Map([...(labels.users ?? []), ...(lookedUp.users ?? [])]),
+ channels: new Map([
+ ...(labels.channels ?? []),
+ ...(lookedUp.channels ?? []),
+ ]),
+ usergroups: labels.usergroups,
+ };
+ const body =
+ richTextToMarkdown(message.blocks, names) ?? message.text?.trim() ?? "";
+ return body || attachmentsText(message);
+}
function system(resolved: SlackWorkspace): ServiceContext {
return {
@@ -131,8 +198,21 @@ export async function handlePinReaction(args: {
try {
if (await alreadyNoted(slack, channel, ts, resolved.botUserId)) return;
const message = await findMessage(slack, channel, ts);
- if (!message?.text) {
+ const body = message
+ ? await noteBody({ resolved, teamId, slack, message })
+ : "";
+ if (!body) {
await redis.del(claim);
+ await slack.chat
+ .postEphemeral({
+ channel,
+ user: slackUserId,
+ thread_ts: ts,
+ text: NOTHING_TO_COPY,
+ })
+ .catch((error) =>
+ logger.warn("slack failed to report an empty pin", { error }),
+ );
return;
}
const permalink = await slack.chat
@@ -145,9 +225,8 @@ export async function handlePinReaction(args: {
ctx,
input: {
id: bound.id,
- message: permalink
- ? `${message.text}\n\n[From Slack](${permalink})`
- : message.text,
+ message: permalink ? `${body}\n\n[From Slack](${permalink})` : body,
+ createdAt: messageDate(ts),
},
});
trackSlackIncident(ctx, "note", { via: "reaction" });
diff --git a/apps/server/src/routes/slack/resolve-slack-user.ts b/apps/server/src/routes/slack/resolve-slack-user.ts
index c65d58b73..ea3ada793 100644
--- a/apps/server/src/routes/slack/resolve-slack-user.ts
+++ b/apps/server/src/routes/slack/resolve-slack-user.ts
@@ -1,55 +1,144 @@
import { getLogger } from "@logtape/logtape";
import type { Workspace } from "@openstatus/db/src/schema/workspaces/validation";
import type { ServiceContext } from "@openstatus/services";
-import { findMemberIdByEmail } from "@openstatus/services/member";
+import {
+ findMemberIdByEmail,
+ getMemberDisplayName,
+} from "@openstatus/services/member";
import {
createSlackUserMapping,
getSlackUserMapping,
} from "@openstatus/services/slack-user";
import type { WebClient } from "@slack/web-api";
+import type { MentionNames } from "./rich-text";
+
const logger = getLogger(["api-server", "slack", "resolve-user"]);
/**
- * The openstatus member linked to a Slack user, or `null`. A missing link is
- * created on the spot when the Slack profile email matches exactly one member.
+ * One `users.info` serves both the email match and the fallback name. Links
+ * the Slack user to the member on an email match, so merely being mentioned
+ * in a pinned message can create the mapping; it is the same rule applied
+ * when they act themselves.
*/
-export async function resolveSlackMember(args: {
+async function lookupSlackMember(args: {
workspace: Workspace;
teamId: string;
slackUserId: string;
slack: WebClient;
-}): Promise<number | null> {
+}): Promise<{ userId: number | null; profileName: string | null }> {
const { workspace, teamId, slackUserId, slack } = args;
- if (!teamId || !slackUserId) return null;
+ if (!teamId || !slackUserId) return { userId: null, profileName: null };
const ctx: ServiceContext = {
workspace,
actor: { type: "system", job: "slack-user-automap" },
};
+ let profileName: string | null = null;
try {
const linked = await getSlackUserMapping({
ctx,
input: { teamId, slackUserId },
});
- if (linked !== null) return linked;
+ if (linked !== null) return { userId: linked, profileName };
const info = await slack.users.info({ user: slackUserId });
+ profileName =
+ info.user?.profile?.display_name ||
+ info.user?.real_name ||
+ info.user?.name ||
+ null;
const email = info.user?.profile?.email;
- if (!email) return null;
+ if (!email) return { userId: null, profileName };
const userId = await findMemberIdByEmail({ ctx, input: { email } });
- if (userId === null) return null;
+ if (userId === null) return { userId: null, profileName };
await createSlackUserMapping({
ctx,
input: { teamId, slackUserId, userId },
});
- return userId;
+ return { userId, profileName };
} catch (err) {
logger.warn("slack user resolution failed", {
workspaceId: workspace.id,
teamId,
error: err instanceof Error ? err.message : String(err),
});
- return null;
+ return { userId: null, profileName };
}
}
+
+/**
+ * The openstatus member linked to a Slack user, or `null`. A missing link is
+ * created on the spot when the Slack profile email matches exactly one member.
+ */
+export async function resolveSlackMember(args: {
+ workspace: Workspace;
+ teamId: string;
+ slackUserId: string;
+ slack: WebClient;
+}): Promise<number | null> {
+ return (await lookupSlackMember(args)).userId;
+}
+
+// A pinned message rarely mentions more than a handful of people; Slack
+// rate-limits `users.info`/`conversations.info`, so look them up a few at a time.
+const MAX_MENTIONS = 20;
+const LOOKUP_CONCURRENCY = 5;
+
+async function forEachBounded<T>(
+ items: T[],
+ fn: (item: T) => Promise<void>,
+): Promise<void> {
+ for (let i = 0; i < items.length; i += LOOKUP_CONCURRENCY) {
+ await Promise.all(items.slice(i, i + LOOKUP_CONCURRENCY).map(fn));
+ }
+}
+
+/**
+ * Names for the users and channels a message mentions: a linked member's
+ * openstatus name, else the Slack profile name, else nothing (the caller
+ * keeps the raw id). Lookups that fail are dropped, never thrown.
+ */
+export async function resolveSlackMentionNames(args: {
+ workspace: Workspace;
+ teamId: string;
+ slack: WebClient;
+ users: string[];
+ channels: string[];
+}): Promise<MentionNames> {
+ const { workspace, teamId, slack } = args;
+ const ctx: ServiceContext = {
+ workspace,
+ actor: { type: "system", job: "slack-user-automap" },
+ };
+ const users = new Map<string, string>();
+ const channels = new Map<string, string>();
+
+ await Promise.all([
+ forEachBounded(args.users.slice(0, MAX_MENTIONS), async (slackUserId) => {
+ const { userId, profileName } = await lookupSlackMember({
+ workspace,
+ teamId,
+ slackUserId,
+ slack,
+ });
+ const memberName =
+ userId === null
+ ? null
+ : await getMemberDisplayName({ ctx, input: { userId } }).catch(
+ () => null,
+ );
+ const name = memberName ?? profileName;
+ if (name) users.set(slackUserId, name);
+ }),
+ forEachBounded(args.channels.slice(0, MAX_MENTIONS), async (channelId) => {
+ const res = await slack.conversations
+ .info({ channel: channelId })
+ .catch(() => undefined);
+ const name = res?.channel?.name;
+ if (name) channels.set(channelId, name);
+ }),
+ ]);
+
+ return { users, channels };
+}
diff --git a/apps/server/src/routes/slack/rich-text.test.ts b/apps/server/src/routes/slack/rich-text.test.ts
new file mode 100644
index 000000000..6aa5d6128
--- /dev/null
+++ b/apps/server/src/routes/slack/rich-text.test.ts
@@ -0,0 +1,404 @@
+import { describe, expect, test } from "@openstatus/test-utils";
+
+import {
+ collectMentions,
+ mentionLabelsFromText,
+ richTextToMarkdown,
+} from "./rich-text";
+
+function section(...elements: unknown[]) {
+ return { type: "rich_text_section", elements };
+}
+
+function message(...elements: unknown[]) {
+ return [{ type: "rich_text", elements }];
+}
+
+describe("richTextToMarkdown", () => {
+ test("returns undefined without a rich_text block", () => {
+ expect(richTextToMarkdown(undefined)).toBeUndefined();
+ expect(richTextToMarkdown([])).toBeUndefined();
+ expect(
+ richTextToMarkdown([{ type: "section", text: { type: "mrkdwn" } }]),
+ ).toBeUndefined();
+ });
+
+ test("renders a standard emoji from its codepoints", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section(
+ { type: "text", text: "oh wow, it syncs omg " },
+ {
+ type: "emoji",
+ name: "face_holding_back_tears",
+ unicode: "1f979",
+ },
+ ),
+ ),
+ ),
+ ).toBe("oh wow, it syncs omg 🥹");
+ });
+
+ test("renders a skin-tone sequence", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section({
+ type: "emoji",
+ name: "+1",
+ skin_tone: 3,
+ unicode: "1f44d-1f3fc",
+ }),
+ ),
+ ),
+ ).toBe("👍🏼");
+ });
+
+ test("keeps a custom emoji as its shortcode", () => {
+ expect(
+ richTextToMarkdown(
+ message(section({ type: "emoji", name: "partyparrot" })),
+ ),
+ ).toBe(":partyparrot:");
+ });
+
+ test("converts styles to markdown", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section(
+ { type: "text", text: "bold", style: { bold: true } },
+ { type: "text", text: " " },
+ { type: "text", text: "italic", style: { italic: true } },
+ { type: "text", text: " " },
+ { type: "text", text: "gone", style: { strike: true } },
+ { type: "text", text: " " },
+ { type: "text", text: "a*b", style: { code: true } },
+ ),
+ ),
+ ),
+ ).toBe("**bold** _italic_ ~~gone~~ `a*b`");
+ });
+
+ test("keeps surrounding whitespace outside style markers", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section(
+ { type: "text", text: "rolled back ", style: { bold: true } },
+ { type: "text", text: "to v41" },
+ ),
+ ),
+ ),
+ ).toBe("**rolled back** to v41");
+ });
+
+ test("converts links with and without a label", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section(
+ { type: "link", url: "https://example.com/run/1", text: "the run" },
+ { type: "text", text: " and " },
+ { type: "link", url: "https://example.com" },
+ ),
+ ),
+ ),
+ ).toBe("[the run](https://example.com/run/1) and <https://example.com>");
+ });
+
+ test("names mentions from the map and falls back to the id", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section(
+ { type: "user", user_id: "U1" },
+ { type: "text", text: " ping " },
+ { type: "user", user_id: "U2" },
+ { type: "text", text: " in " },
+ { type: "channel", channel_id: "C1" },
+ { type: "text", text: " " },
+ { type: "channel", channel_id: "C2" },
+ ),
+ ),
+ {
+ users: new Map([["U1", "Maximilian Kaske"]]),
+ channels: new Map([["C1", "inc-db"]]),
+ },
+ ),
+ ).toBe("@Maximilian Kaske ping @U2 in #inc-db #C2");
+ });
+
+ test("escapes markdown specials in names and plain text", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section(
+ { type: "user", user_id: "U1" },
+ { type: "text", text: " said 2*3 is_fine [sic]" },
+ ),
+ ),
+ { users: new Map([["U1", "jo_hn"]]) },
+ ),
+ ).toBe("@jo\\_hn said 2\\*3 is\\_fine \\[sic\\]");
+ });
+
+ test("names a user group from the map and falls back to the id", () => {
+ const blocks = message(
+ section(
+ { type: "usergroup", usergroup_id: "S1" },
+ { type: "text", text: " " },
+ { type: "usergroup", usergroup_id: "S2" },
+ ),
+ );
+ expect(
+ richTextToMarkdown(blocks, {
+ usergroups: new Map([["S1", "engineering"]]),
+ }),
+ ).toBe("@engineering @S2");
+ });
+
+ test("renders broadcasts", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section(
+ { type: "broadcast", range: "here" },
+ { type: "text", text: " db is back" },
+ ),
+ ),
+ ),
+ ).toBe("@here db is back");
+ });
+
+ test("renders lists, quotes and code blocks", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section({ type: "text", text: "Findings:" }),
+ {
+ type: "rich_text_list",
+ style: "bullet",
+ elements: [
+ section({ type: "text", text: "one" }),
+ section({ type: "text", text: "two" }),
+ ],
+ },
+ {
+ type: "rich_text_list",
+ style: "ordered",
+ indent: 1,
+ elements: [section({ type: "text", text: "nested" })],
+ },
+ {
+ type: "rich_text_quote",
+ elements: [{ type: "text", text: "quoted\nlines" }],
+ },
+ {
+ type: "rich_text_preformatted",
+ elements: [{ type: "text", text: "SELECT *\nFROM t;" }],
+ },
+ ),
+ ),
+ ).toBe(
+ [
+ "Findings:",
+ "",
+ "- one\n- two\n 1. nested",
+ "",
+ "> quoted\n> lines",
+ "",
+ "```\nSELECT *\nFROM t;\n```",
+ ].join("\n"),
+ );
+ });
+
+ test("escapes a line-start dash so it does not become a list", () => {
+ expect(
+ richTextToMarkdown(
+ message(section({ type: "text", text: "- not a list" })),
+ ),
+ ).toBe("\\- not a list");
+ });
+});
+
+describe("richTextToMarkdown edge cases", () => {
+ test("honors the ordered-list offset", () => {
+ expect(
+ richTextToMarkdown(
+ message({
+ type: "rich_text_list",
+ style: "ordered",
+ offset: 2,
+ elements: [
+ section({ type: "text", text: "third" }),
+ section({ type: "text", text: "fourth" }),
+ ],
+ }),
+ ),
+ ).toBe("3. third\n4. fourth");
+ });
+
+ test("escapes tildes so literal text is not struck through", () => {
+ expect(
+ richTextToMarkdown(
+ message(section({ type: "text", text: "~~not gone~~" })),
+ ),
+ ).toBe("\\~\\~not gone\\~\\~");
+ });
+
+ test("widens code delimiters past the backticks inside", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section({ type: "text", text: "a `b` c", style: { code: true } }),
+ {
+ type: "rich_text_preformatted",
+ elements: [{ type: "text", text: "```\nx\n```" }],
+ },
+ ),
+ ),
+ ).toBe("``a `b` c``\n\n````\n```\nx\n```\n````");
+ });
+
+ test("pads inline code that starts or ends with a backtick", () => {
+ expect(
+ richTextToMarkdown(
+ message(section({ type: "text", text: "`x", style: { code: true } })),
+ ),
+ ).toBe("`` `x ``");
+ expect(
+ richTextToMarkdown(
+ message(section({ type: "text", text: "x`", style: { code: true } })),
+ ),
+ ).toBe("`` x` ``");
+ });
+
+ test("keeps a multi-line list item inside the item", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ {
+ type: "rich_text_list",
+ style: "ordered",
+ offset: 9,
+ elements: [section({ type: "text", text: "first\nstill first" })],
+ },
+ {
+ type: "rich_text_list",
+ style: "bullet",
+ indent: 1,
+ elements: [section({ type: "text", text: "a\nb" })],
+ },
+ ),
+ ),
+ ).toBe("10. first\n still first\n - a\n b");
+ });
+
+ test("escapes block syntax at line start, also inside quotes", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section({ type: "text", text: "## not a heading\n---\n+ no\n1) no" }),
+ {
+ type: "rich_text_quote",
+ elements: [{ type: "text", text: "# q" }],
+ },
+ ),
+ ),
+ ).toBe("\\## not a heading\n\\---\n\\+ no\n\\1) no\n\n> \\# q");
+ });
+
+ test("renders a link with an unsafe scheme as plain text", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section(
+ { type: "link", url: "javascript:alert(1)", text: "click" },
+ { type: "text", text: " " },
+ { type: "link", url: "javascript:alert(1)" },
+ { type: "text", text: " " },
+ { type: "link", url: "mailto:[email protected]" },
+ ),
+ ),
+ ),
+ ).toBe("click javascript:alert(1) <mailto:[email protected]>");
+ });
+
+ test("encodes spaces and parentheses in link destinations", () => {
+ expect(
+ richTextToMarkdown(
+ message(
+ section(
+ { type: "link", url: "https://w.org/wiki/Foo_(bar)", text: "wiki" },
+ { type: "text", text: " " },
+ { type: "link", url: "https://e.com/a b" },
+ ),
+ ),
+ ),
+ ).toBe("[wiki](https://w.org/wiki/Foo_%28bar%29) <https://e.com/a%20b>");
+ });
+});
+
+describe("mentionLabelsFromText", () => {
+ test("harvests the labels Slack spelled out in mrkdwn", () => {
+ const names = mentionLabelsFromText(
+ "<@U1|max> ping <!subteam^S1|@engineering> in <#C1|inc-db> and <#C2>",
+ );
+ expect(names.users).toEqual(new Map([["U1", "max"]]));
+ expect(names.usergroups).toEqual(new Map([["S1", "engineering"]]));
+ expect(names.channels).toEqual(new Map([["C1", "inc-db"]]));
+ });
+
+ test("is empty without text", () => {
+ expect(mentionLabelsFromText(undefined).users?.size).toBe(0);
+ });
+});
+
+describe("collectMentions", () => {
+ test("dedupes user and channel ids across blocks", () => {
+ expect(
+ collectMentions(
+ message(
+ section(
+ { type: "user", user_id: "U1" },
+ { type: "channel", channel_id: "C1" },
+ ),
+ {
+ type: "rich_text_quote",
+ elements: [
+ { type: "user", user_id: "U1" },
+ { type: "user", user_id: "U2" },
+ ],
+ },
+ ),
+ ),
+ ).toEqual({ users: ["U1", "U2"], channels: ["C1"] });
+ });
+
+ test("is empty without rich_text", () => {
+ expect(collectMentions(undefined)).toEqual({ users: [], channels: [] });
+ });
+
+ test("finds mentions inside list items", () => {
+ const blocks = message({
+ type: "rich_text_list",
+ style: "bullet",
+ elements: [
+ section(
+ { type: "user", user_id: "U5" },
+ { type: "text", text: " owns it" },
+ ),
+ section({ type: "channel", channel_id: "C5" }),
+ ],
+ });
+ expect(collectMentions(blocks)).toEqual({
+ users: ["U5"],
+ channels: ["C5"],
+ });
+ expect(
+ richTextToMarkdown(blocks, { users: new Map([["U5", "Sam"]]) }),
+ ).toBe("- @Sam owns it\n- #C5");
+ });
+});
diff --git a/apps/server/src/routes/slack/rich-text.ts b/apps/server/src/routes/slack/rich-text.ts
new file mode 100644
index 000000000..1830125d1
--- /dev/null
+++ b/apps/server/src/routes/slack/rich-text.ts
@@ -0,0 +1,316 @@
+/**
+ * Slack attaches `rich_text` blocks to every user-typed message. They carry
+ * what `message.text` (mrkdwn) loses: emoji codepoints, structured mentions
+ * and links, styles. Convert them to the markdown the timeline renders.
+ *
+ * Structural types instead of `@slack/types`: the package is only a
+ * transitive dep and the fields used here are stable.
+ */
+
+type Style = {
+ bold?: boolean;
+ italic?: boolean;
+ strike?: boolean;
+ code?: boolean;
+};
+
+type InlineElement =
+ | { type: "text"; text: string; style?: Style }
+ | { type: "emoji"; name: string; unicode?: string; style?: Style }
+ | { type: "link"; url: string; text?: string; style?: Style }
+ | { type: "user"; user_id: string; style?: Style }
+ | { type: "channel"; channel_id: string; style?: Style }
+ | { type: "usergroup"; usergroup_id: string; style?: Style }
+ | { type: "broadcast"; range: string; style?: Style }
+ | { type: "date"; fallback?: string; style?: Style }
+ | { type: "color"; value: string; style?: Style };
+
+type Section = { type: "rich_text_section"; elements: InlineElement[] };
+type List = {
+ type: "rich_text_list";
+ style: "bullet" | "ordered";
+ indent?: number;
+ offset?: number;
+ elements: Section[];
+};
+type Quote = { type: "rich_text_quote"; elements: InlineElement[] };
+type Preformatted = {
+ type: "rich_text_preformatted";
+ elements: InlineElement[];
+};
+type RichTextElement = Section | List | Quote | Preformatted;
+type RichTextBlock = { type: "rich_text"; elements: RichTextElement[] };
+
+export type MentionNames = {
+ users?: Map<string, string>;
+ channels?: Map<string, string>;
+ usergroups?: Map<string, string>;
+};
+
+// `<@U1|max>`, `<#C1|inc-db>`, `<!subteam^S1|@engineering>` in mrkdwn `text`.
+const LABELLED_MENTION = /<([@#]|!subteam\^)([A-Z0-9]+)\|@?([^>|]+)>/g;
+
+/**
+ * Names Slack already spelled out in `message.text`. The only source for a
+ * user group's handle, since `rich_text` carries just its id and reading
+ * groups would need a scope we do not request.
+ */
+export function mentionLabelsFromText(text: string | undefined): MentionNames {
+ const names: Required<MentionNames> = {
+ users: new Map(),
+ channels: new Map(),
+ usergroups: new Map(),
+ };
+ for (const match of (text ?? "").matchAll(LABELLED_MENTION)) {
+ const [, kind, id, label] = match;
+ const target =
+ kind === "@"
+ ? names.users
+ : kind === "#"
+ ? names.channels
+ : names.usergroups;
+ target.set(id, label.trim());
+ }
+ return names;
+}
+
+function isRichTextBlock(block: unknown): block is RichTextBlock {
+ return (
+ typeof block === "object" &&
+ block !== null &&
+ (block as { type?: unknown }).type === "rich_text" &&
+ Array.isArray((block as { elements?: unknown }).elements)
+ );
+}
+
+function richTextBlocks(blocks: unknown[] | undefined): RichTextBlock[] {
+ return (blocks ?? []).filter(isRichTextBlock);
+}
+
+/** A list's children are sections; everything else holds inlines directly. */
+function inlinesOf(element: RichTextElement): InlineElement[] {
+ if (element.type === "rich_text_list") {
+ return element.elements.flatMap((item) => item.elements ?? []);
+ }
+ return element.elements ?? [];
+}
+
+/** Every user and channel id mentioned, deduplicated, for the caller to resolve. */
+export function collectMentions(blocks: unknown[] | undefined): {
+ users: string[];
+ channels: string[];
+} {
+ const users = new Set<string>();
+ const channels = new Set<string>();
+ for (const block of richTextBlocks(blocks)) {
+ for (const element of block.elements) {
+ for (const inline of inlinesOf(element)) {
+ if (inline.type === "user") users.add(inline.user_id);
+ if (inline.type === "channel") channels.add(inline.channel_id);
+ }
+ }
+ }
+ return { users: [...users], channels: [...channels] };
+}
+
+// Only what remark would otherwise interpret; `#`, `>`, `-` matter at line start.
+const INLINE_SPECIALS = /[\\`*_~[\]]/g;
+const LINE_START_SPECIALS =
+ /^(\s*)(#{1,6}|>|[-+]|-{3,}|={3,}|\d+[.)])(?=\s|$)/gm;
+
+function escapeText(text: string): string {
+ return text
+ .replace(INLINE_SPECIALS, "\\$&")
+ .replace(LINE_START_SPECIALS, "$1\\$2");
+}
+
+function longestBacktickRun(text: string): number {
+ let max = 0;
+ for (const match of text.matchAll(/`+/g)) {
+ max = Math.max(max, match[0].length);
+ }
+ return max;
+}
+
+/** A delimiter longer than any backtick run inside, so the span cannot close early. */
+function inlineCode(text: string): string {
+ const fence = "`".repeat(longestBacktickRun(text) + 1);
+ const pad = text.startsWith("`") || text.endsWith("`") ? " " : "";
+ return `${fence}${pad}${text}${pad}${fence}`;
+}
+
+function codeFence(code: string): string {
+ const fence = "`".repeat(Math.max(3, longestBacktickRun(code) + 1));
+ return `${fence}\n${code}\n${fence}`;
+}
+
+// Not every renderer sanitizes `javascript:`; anything else becomes plain text.
+const SAFE_LINK = /^(https?:|mailto:)/i;
+
+/** Spaces and parentheses end a markdown destination early; `<>` break autolinks. */
+function linkDestination(url: string): string {
+ return url.replace(
+ /[ ()<>]/g,
+ (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,
+ );
+}
+
+/** `"1f44d-1f3fc"` → 👍🏼. Hyphen-separated hex codepoints. */
+function emojiFromUnicode(unicode: string): string | undefined {
+ const points = unicode.split("-").map((hex) => Number.parseInt(hex, 16));
+ if (points.length === 0 || points.some((p) => !Number.isFinite(p))) {
+ return undefined;
+ }
+ try {
+ return String.fromCodePoint(...points);
+ } catch {
+ return undefined;
+ }
+}
+
+/** Markers must hug the text, or remark reads `**bold **` literally. */
+function applyStyle(text: string, style: Style | undefined): string {
+ if (!style || !text.trim()) return text;
+ const leading = text.match(/^\s*/)?.[0] ?? "";
+ const trailing = text.match(/\s*$/)?.[0] ?? "";
+ let inner = text.slice(leading.length, text.length - trailing.length);
+ if (style.code) {
+ inner = inlineCode(inner);
+ } else {
+ if (style.strike) inner = `~~${inner}~~`;
+ if (style.italic) inner = `_${inner}_`;
+ if (style.bold) inner = `**${inner}**`;
+ }
+ return `${leading}${inner}${trailing}`;
+}
+
+function renderInline(element: InlineElement, names: MentionNames): string {
+ switch (element.type) {
+ case "text":
+ return applyStyle(
+ element.style?.code ? element.text : escapeText(element.text),
+ element.style,
+ );
+ case "emoji": {
+ const char = element.unicode
+ ? emojiFromUnicode(element.unicode)
+ : undefined;
+ return applyStyle(char ?? `:${element.name}:`, element.style);
+ }
+ case "link": {
+ const label = element.text?.trim();
+ if (!SAFE_LINK.test(element.url)) {
+ return applyStyle(escapeText(label || element.url), element.style);
+ }
+ const url = linkDestination(element.url);
+ const md =
+ label && label !== element.url
+ ? `[${escapeText(label)}](${url})`
+ : `<${url}>`;
+ return applyStyle(md, element.style);
+ }
+ case "user": {
+ const name = names.users?.get(element.user_id);
+ return applyStyle(
+ `@${escapeText(name ?? element.user_id)}`,
+ element.style,
+ );
+ }
+ case "channel": {
+ const name = names.channels?.get(element.channel_id);
+ return applyStyle(
+ `#${escapeText(name ?? element.channel_id)}`,
+ element.style,
+ );
+ }
+ case "usergroup": {
+ const name = names.usergroups?.get(element.usergroup_id);
+ return applyStyle(
+ `@${escapeText(name ?? element.usergroup_id)}`,
+ element.style,
+ );
+ }
+ case "broadcast":
+ return applyStyle(`@${element.range}`, element.style);
+ case "date":
+ return applyStyle(escapeText(element.fallback ?? ""), element.style);
+ case "color":
+ return applyStyle(escapeText(element.value), element.style);
+ default:
+ return "";
+ }
+}
+
+function renderInlines(elements: InlineElement[], names: MentionNames): string {
+ return elements.map((element) => renderInline(element, names)).join("");
+}
+
+// Wide enough to nest under `1. ` (3 columns) as well as `- `.
+const LIST_INDENT = " ";
+
+function renderElement(element: RichTextElement, names: MentionNames): string {
+ switch (element.type) {
+ case "rich_text_section":
+ return renderInlines(element.elements, names);
+ case "rich_text_list": {
+ const pad = LIST_INDENT.repeat(element.indent ?? 0);
+ const start = (element.offset ?? 0) + 1;
+ return element.elements
+ .map((item, index) => {
+ const marker =
+ element.style === "ordered" ? `${start + index}.` : "-";
+ // Continuation lines stay inside the item when indented to its text.
+ const hang = `\n${pad}${" ".repeat(marker.length + 1)}`;
+ const text = renderInlines(item.elements, names).replace(/\n/g, hang);
+ return `${pad}${marker} ${text}`;
+ })
+ .join("\n");
+ }
+ case "rich_text_quote":
+ return renderInlines(element.elements, names)
+ .split("\n")
+ .map((line) => `> ${line}`)
+ .join("\n");
+ case "rich_text_preformatted":
+ return codeFence(
+ element.elements
+ .map((inline) =>
+ inline.type === "text"
+ ? inline.text
+ : inline.type === "link"
+ ? (inline.text ?? inline.url)
+ : "",
+ )
+ .join(""),
+ );
+ default:
+ return "";
+ }
+}
+
+/**
+ * Markdown for a message's `rich_text` blocks, or `undefined` when there are
+ * none so the caller falls back to `message.text`.
+ */
+export function richTextToMarkdown(
+ blocks: unknown[] | undefined,
+ names: MentionNames = {},
+): string | undefined {
+ const rich = richTextBlocks(blocks);
+ if (rich.length === 0) return undefined;
+ let out = "";
+ let previous: RichTextElement["type"] | undefined;
+ for (const block of rich) {
+ for (const element of block.elements) {
+ const rendered = renderElement(element, names);
+ if (!rendered.trim()) continue;
+ // Slack emits one list per nesting level; a blank line would split them.
+ const adjacentLists =
+ previous === "rich_text_list" && element.type === "rich_text_list";
+ if (out) out += adjacentLists ? "\n" : "\n\n";
+ out += rendered;
+ previous = element.type;
+ }
+ }
+ return out.trim() || undefined;
+}
diff --git a/packages/services/src/incident/__tests__/incident.test.ts b/packages/services/src/incident/__tests__/incident.test.ts
index 640c411bd..7dc78c156 100644
--- a/packages/services/src/incident/__tests__/incident.test.ts
+++ b/packages/services/src/incident/__tests__/incident.test.ts
@@ -459,6 +459,43 @@ describe("addIncidentNote", () => {
});
});
+ test("keeps a createdAt inside the window and treats null as now", async () => {
+ await withTestTransaction(async (tx) => {
+ const row = await declare(tx);
+ const saidAt = new Date(Date.now() - 60 * 60 * 1000);
+ const backdated = await addIncidentNote({
+ ctx: as(memberId, tx),
+ input: { id: row.id, message: "an hour ago", createdAt: saidAt },
+ });
+ // `created_at` is stored in whole seconds.
+ expect(
+ Math.abs(backdated.createdAt.getTime() - saidAt.getTime()),
+ ).toBeLessThan(1000);
+ const now = await addIncidentNote({
+ ctx: as(memberId, tx),
+ input: { id: row.id, message: "now", createdAt: null },
+ });
+ expect(Math.abs(now.createdAt.getTime() - Date.now())).toBeLessThan(5000);
+ });
+ });
+
+ test("rejects a createdAt in the future or older than the window", async () => {
+ await withTestTransaction(async (tx) => {
+ const row = await declare(tx);
+ for (const createdAt of [
+ new Date(Date.now() + 10 * 60 * 1000),
+ new Date(Date.now() - 31 * 24 * 60 * 60 * 1000),
+ ]) {
+ await expect(
+ addIncidentNote({
+ ctx: as(memberId, tx),
+ input: { id: row.id, message: "off the timeline", createdAt },
+ }),
+ ).rejects.toThrow(/createdAt must be within the last 30 days/);
+ }
+ });
+ });
+
test("a closed incident takes no notes", async () => {
await withTestTransaction(async (tx) => {
const row = await createIncident(
diff --git a/packages/services/src/incident/add-note.ts b/packages/services/src/incident/add-note.ts
index d518408c2..106f08425 100644
--- a/packages/services/src/incident/add-note.ts
+++ b/packages/services/src/incident/add-note.ts
@@ -32,6 +32,7 @@ export async function addIncidentNote(args: {
incidentId: existing.id,
type: "note",
message: input.message,
+ createdAt: input.createdAt ?? undefined,
});
});
}
diff --git a/packages/services/src/incident/index.ts b/packages/services/src/incident/index.ts
index 7130a9837..b4f6ddfbb 100644
--- a/packages/services/src/incident/index.ts
+++ b/packages/services/src/incident/index.ts
@@ -37,6 +37,9 @@ export {
} from "./postmortem-draft";
export {
AddIncidentNoteInput,
+ isAllowedNoteCreatedAt,
+ NOTE_BACKDATE_MAX_MS,
+ NOTE_FUTURE_SKEW_MS,
ApprovePostmortemInput,
CloseIncidentInput,
DraftPostmortemInput,
diff --git a/packages/services/src/incident/schemas.ts b/packages/services/src/incident/schemas.ts
index 125857b31..4c6599357 100644
--- a/packages/services/src/incident/schemas.ts
+++ b/packages/services/src/incident/schemas.ts
@@ -42,7 +42,31 @@ export const SetIncidentStatusInput = z.object({
});
export type SetIncidentStatusInput = z.infer<typeof SetIncidentStatusInput>;
-export const AddIncidentNoteInput = z.object({ id, message: note });
+// A note copied from elsewhere (Slack) may keep the time it was said, within
+// a window that keeps the timeline honest for every caller of the verb.
+export const NOTE_BACKDATE_MAX_MS = 30 * 24 * 60 * 60 * 1000;
+export const NOTE_FUTURE_SKEW_MS = 60_000;
+
+export function isAllowedNoteCreatedAt(date: Date, now = Date.now()): boolean {
+ const ms = date.getTime();
+ return (
+ Number.isFinite(ms) &&
+ ms <= now + NOTE_FUTURE_SKEW_MS &&
+ ms >= now - NOTE_BACKDATE_MAX_MS
+ );
+}
+
+export const AddIncidentNoteInput = z.object({
+ id,
+ message: note,
+ createdAt: z.coerce
+ .date()
+ .refine((d) => isAllowedNoteCreatedAt(d), {
+ message:
+ "createdAt must be within the last 30 days and at most a minute ahead",
+ })
+ .nullish(),
+});
export type AddIncidentNoteInput = z.infer<typeof AddIncidentNoteInput>;
export const LinkIncidentStatusReportInput = z.object({
diff --git a/packages/services/src/member/__tests__/display-name.test.ts b/packages/services/src/member/__tests__/display-name.test.ts
new file mode 100644
index 000000000..8cc7adc83
--- /dev/null
+++ b/packages/services/src/member/__tests__/display-name.test.ts
@@ -0,0 +1,44 @@
+import {
+ addUserToWorkspace,
+ createUser,
+} from "@openstatus/db/src/test/factories";
+import { expect } from "@std/expect";
+import { beforeAll, describe, test } from "@std/testing/bdd";
+
+import { createWorkspaceFixture, makeSystemCtx } from "../../../test/helpers";
+import type { ServiceContext } from "../../context";
+import { getMemberDisplayName } from "../index.ts";
+
+let ctx: ServiceContext;
+let workspaceId: number;
+
+beforeAll(async () => {
+ const fixture = await createWorkspaceFixture("team");
+ workspaceId = fixture.workspace.id;
+ ctx = makeSystemCtx(fixture.workspace, { job: "slack-user-automap" });
+});
+
+describe("getMemberDisplayName", () => {
+ test("prefers the explicit name over first and last", async () => {
+ const member = await createUser({ name: "Max K." });
+ await addUserToWorkspace(member.id, workspaceId, "member");
+ expect(
+ await getMemberDisplayName({ ctx, input: { userId: member.id } }),
+ ).toBe("Max K.");
+ });
+
+ test("falls back to first and last name", async () => {
+ const member = await createUser({ name: null });
+ await addUserToWorkspace(member.id, workspaceId, "member");
+ expect(
+ await getMemberDisplayName({ ctx, input: { userId: member.id } }),
+ ).toBe("Test User");
+ });
+
+ test("returns null for a user who is not a member here", async () => {
+ const outsider = await createUser();
+ expect(
+ await getMemberDisplayName({ ctx, input: { userId: outsider.id } }),
+ ).toBeNull();
+ });
+});
diff --git a/packages/services/src/member/display-name.ts b/packages/services/src/member/display-name.ts
new file mode 100644
index 000000000..6a35fdafc
--- /dev/null
+++ b/packages/services/src/member/display-name.ts
@@ -0,0 +1,32 @@
+import { and, eq, isNull } from "@openstatus/db";
+import { user, usersToWorkspaces } from "@openstatus/db/src/schema";
+
+import { displayName } from "../attribution";
+import { type ServiceContext, getReadDb } from "../context";
+import { GetMemberDisplayNameInput } from "./schemas";
+
+/** The display name of a live member of this workspace, or `null`. */
+export async function getMemberDisplayName(args: {
+ ctx: ServiceContext;
+ input: GetMemberDisplayNameInput;
+}): Promise<string | null> {
+ const input = GetMemberDisplayNameInput.parse(args.input);
+ const row = await getReadDb(args.ctx)
+ .select({
+ name: user.name,
+ firstName: user.firstName,
+ lastName: user.lastName,
+ email: user.email,
+ })
+ .from(usersToWorkspaces)
+ .innerJoin(user, eq(user.id, usersToWorkspaces.userId))
+ .where(
+ and(
+ eq(usersToWorkspaces.workspaceId, args.ctx.workspace.id),
+ eq(usersToWorkspaces.userId, input.userId),
+ isNull(user.deletedAt),
+ ),
+ )
+ .get();
+ return row ? displayName(row) : null;
+}
diff --git a/packages/services/src/member/index.ts b/packages/services/src/member/index.ts
index 10cc2823e..6582ab10e 100644
--- a/packages/services/src/member/index.ts
+++ b/packages/services/src/member/index.ts
@@ -1,8 +1,10 @@
export { deleteMember } from "./delete";
+export { getMemberDisplayName } from "./display-name";
export { findMemberIdByEmail } from "./find-by-email";
export { listMembers, type Member } from "./list";
export {
DeleteMemberInput,
FindMemberByEmailInput,
+ GetMemberDisplayNameInput,
ListMembersInput,
} from "./schemas";
diff --git a/packages/services/src/member/schemas.ts b/packages/services/src/member/schemas.ts
index 0e24564a0..db5605c44 100644
--- a/packages/services/src/member/schemas.ts
+++ b/packages/services/src/member/schemas.ts
@@ -8,3 +8,8 @@ export type DeleteMemberInput = z.infer<typeof DeleteMemberInput>;
export const FindMemberByEmailInput = z.object({ email: z.string() });
export type FindMemberByEmailInput = z.infer<typeof FindMemberByEmailInput>;
+
+export const GetMemberDisplayNameInput = z.object({ userId: z.number().int() });
+export type GetMemberDisplayNameInput = z.infer<
+ typeof GetMemberDisplayNameInput
+>;