feat: configurable user profile information

apps/core/migrations/20261007150000_profile_display.cjs

@@ -0,0 +1,14 @@
+exports.up = async (knex) => {
+  await knex.schema
+    .withSchema("public")
+    .createTable("asmblyr_profile_display", (table) => {
+      table.integer("id").primary();
+      table.text("title").notNullable().defaultTo("");
+      table.jsonb("entries").notNullable().defaultTo("[]");
+    });
+  await knex("public.asmblyr_profile_display").insert({ id: 1 });
+};
+
+exports.down = async (knex) => {
+  await knex.schema.withSchema("public").dropTable("asmblyr_profile_display");
+};

apps/core/src/app.ts

@@ -20,6 +20,7 @@ import {
 import { registerUserRoutes } from "./auth/user-routes.js";
 import { registerProfileRoutes } from "./auth/profile-routes.js";
 import { registerProfileExtensionRoutes } from "./auth/profile-extension-routes.js";
+import { registerProfileDisplayRoutes } from "./auth/profile-display-routes.js";
 import { registerProfileAvatarRoutes } from "./auth/profile-avatar-routes.js";
 import { registerServiceRoutes } from "./services/routes.js";
 import { registerServiceActivity } from "./services/activity.js";
@@ -239,6 +240,7 @@ export function createApp({
   registerProfileRoutes(app, database);
   registerProfileAvatarRoutes(app, database, storageSource);
   registerProfileExtensionRoutes(app, database, hooks.mutation);
+  registerProfileDisplayRoutes(app, database);
   registerPresenceRoutes(app, database);
   registerNotificationRoutes(app, database, plugins);
   registerServiceRoutes(app, database);

apps/core/src/auth/profile-display-config.ts

@@ -0,0 +1,105 @@
+import type { Knex } from "knex";
+import type {
+  ProfileDisplayConfiguration,
+  ProfileDisplayEntry,
+} from "@asmblyr-collaborative/contracts";
+import { InputError, objectInput, textInput } from "../shared/input.js";
+import { securityEvent } from "./security-events.js";
+import {
+  parseDisplayPath,
+  profileDisplaySchema,
+} from "./profile-display-schema.js";
+
+export interface StoredDisplayEntry extends ProfileDisplayEntry {
+  signature: string;
+}
+export interface StoredDisplayConfiguration {
+  title: string;
+  entries: StoredDisplayEntry[];
+}
+
+export async function storedProfileDisplay(
+  db: Knex,
+): Promise<StoredDisplayConfiguration> {
+  return await db("public.asmblyr_profile_display")
+    .where({ id: 1 })
+    .first("title", "entries");
+}
+
+export async function getProfileDisplayConfiguration(
+  db: Knex,
+): Promise<ProfileDisplayConfiguration> {
+  const config = await storedProfileDisplay(db);
+  return {
+    title: config.title,
+    entries: config.entries.map(({ id, label, path, selfVisible }) => ({
+      id,
+      label,
+      path,
+      selfVisible,
+    })),
+  };
+}
+
+function parseConfiguration(input: unknown): ProfileDisplayConfiguration {
+  const body = objectInput(input, ["title", "entries"]);
+  const title = textInput(body.title, 100, true);
+  if (!Array.isArray(body.entries) || body.entries.length > 12) {
+    throw new InputError("A profile display supports up to 12 entries");
+  }
+  const ids = new Set<string>();
+  const entries = body.entries.map((value): ProfileDisplayEntry => {
+    const entry = objectInput(value, ["id", "label", "path", "selfVisible"]);
+    if (
+      typeof entry.id !== "string" ||
+      !/^[a-zA-Z0-9_-]{1,64}$/.test(entry.id) ||
+      ids.has(entry.id) ||
+      typeof entry.selfVisible !== "boolean"
+    ) {
+      throw new InputError("Invalid profile display entry");
+    }
+    ids.add(entry.id);
+    return {
+      id: entry.id,
+      label: textInput(entry.label, 100),
+      path: parseDisplayPath(entry.path),
+      selfVisible: entry.selfVisible,
+    };
+  });
+  return { title, entries };
+}
+
+export async function saveProfileDisplayConfiguration(
+  db: Knex,
+  input: unknown,
+  actorId: string,
+): Promise<ProfileDisplayConfiguration> {
+  const config = parseConfiguration(input);
+  return db.transaction(async (trx) => {
+    const schema = await profileDisplaySchema(trx);
+    const entries = config.entries.map((entry) => ({
+      ...entry,
+      signature: schema.resolve(entry.path).signature,
+    }));
+    await trx("public.asmblyr_profile_display")
+      .where({ id: 1 })
+      .update({
+        title: config.title,
+        entries: JSON.stringify(entries),
+      });
+    await securityEvent(
+      trx,
+      actorId,
+      "users.profile_display_configured",
+      actorId,
+      {
+        entries: entries.map(({ id, path, selfVisible }) => ({
+          id,
+          path,
+          selfVisible,
+        })),
+      },
+    );
+    return config;
+  });
+}

apps/core/src/auth/profile-display-routes.ts

@@ -0,0 +1,76 @@
+import type { FastifyInstance } from "fastify";
+import type { Knex } from "knex";
+import { requireSuperuser } from "./require-superuser.js";
+import { requireSettingsRead } from "../settings/access.js";
+import { authenticateAccess } from "./tokens.js";
+import { parseUserId } from "./validation.js";
+import { objectInput, InputError } from "../shared/input.js";
+import {
+  getProfileDisplayConfiguration,
+  saveProfileDisplayConfiguration,
+} from "./profile-display-config.js";
+import {
+  parseDisplayPath,
+  profileDisplaySchema,
+} from "./profile-display-schema.js";
+import { readProfileDisplay } from "./profile-display.js";
+
+export function registerProfileDisplayRoutes(
+  app: FastifyInstance,
+  database: Knex | null,
+): void {
+  function db(): Knex {
+    if (!database) {
+      throw Object.assign(new Error("Database is not configured"), {
+        statusCode: 503,
+      });
+    }
+    return database;
+  }
+  app.get("/users/profile-display", async (request, reply) => {
+    await requireSuperuser(db(), request);
+    return reply
+      .header("Cache-Control", "no-store")
+      .send({ data: await getProfileDisplayConfiguration(db()) });
+  });
+  app.put("/users/profile-display", async (request, reply) => {
+    const actor = await requireSuperuser(db(), request);
+    return reply.header("Cache-Control", "no-store").send({
+      data: await saveProfileDisplayConfiguration(db(), request.body, actor.id),
+    });
+  });
+  app.get("/users/profile-display/sources", async (request, reply) => {
+    await requireSuperuser(db(), request);
+    const query = objectInput(request.query, ["path"]);
+    if (query.path !== undefined && typeof query.path !== "string") {
+      throw new InputError("Invalid profile display path");
+    }
+    const path = parseDisplayPath(
+      query.path ? (query.path as string).split(".") : [],
+      true,
+    );
+    const schema = await profileDisplaySchema(db());
+    return reply
+      .header("Cache-Control", "no-store")
+      .send({ data: schema.choices(path) });
+  });
+  app.get("/users/me/profile-display", async (request, reply) => {
+    const user = await authenticateAccess(db(), request.headers.authorization);
+    return reply
+      .header("Cache-Control", "no-store")
+      .send({ data: await readProfileDisplay(db(), user.id, true) });
+  });
+  app.get<{ Params: { id: string } }>(
+    "/users/:id/profile-display",
+    async (request, reply) => {
+      await requireSettingsRead(db(), request, "users");
+      return reply.header("Cache-Control", "no-store").send({
+        data: await readProfileDisplay(
+          db(),
+          parseUserId(request.params.id),
+          false,
+        ),
+      });
+    },
+  );
+}