User Identity Resolution

The Mallnline frontend stores user relationships as opaque UUIDs — team members, collaborators, blog authors, and Murchase participants are all referenced by their internal userId. Displaying these raw identifiers to end users is a security and UX violation.

The Profile Resolver is a shared utility that batch-resolves user IDs into human-readable profiles (v|handle, displayName, or anonymous fallbacks). It is consumed by every component that displays user attribution, most notably the ActorBadge component.

The Problem

Many backend relationships reference users by their auth-service UUID:

// What the backend returns
{ userId: "a3f8c912-7b4d-4e1a-9f2c-3d5e7a8b1c0d", role: "LEAD" }

// What the user sees (BEFORE fix)
"a3f8c912…"

// What the user sees (AFTER fix)
"@meekdenzo" or "Meek Denzo"

The Handle System provides the sigil taxonomy (v|meekdenzo, @meekdenzo), but until profile data is fetched from the nodes subgraph, the frontend only has raw UUIDs. The Profile Resolver bridges this gap.

Architecture

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   TeamCard.svelte│     │ CollaboratorCard │     │ BlogAnalytics   │
│   TeamsPanel     │     │ CollabPanel      │     │                 │
└────────┬────────┘     └────────┬────────┘     └────────┬────────┘
         │                       │                       │
         └──────────┬────────────┘───────────────────────┘
                    ▼
         ┌─────────────────────┐
         │  profileResolver.ts │  ← Shared utility
         │  resolveUserProfiles│
         │  formatUserDisplay  │
         │  getAvatarInitials  │
         └────────┬────────────┘
                  ▼
         ┌─────────────────────┐
         │  GET_USER_BY_ID     │  ← GraphQL query (nodes subgraph)
         │  user(id: $id) {    │
         │    id, displayName, │
         │    handle, avatarUrl│
         │  }                  │
         └─────────────────────┘

API Reference

`resolveUserProfiles(userIds, existingCache?)`

Batch-resolves an array of user UUIDs into profile info. Deduplicates before querying and merges results into the provided cache.

import { resolveUserProfiles, type ProfileMap } from '$lib/utils/profileResolver';

const profiles: ProfileMap = await resolveUserProfiles(
  ['uuid-1', 'uuid-2', 'uuid-3'],
  existingCache  // Optional — avoids re-fetching known profiles
);

Parameters:

Returns: Promise<ProfileMap> — merged map of userId → UserProfileInfo

Error handling: Individual resolution failures are silently absorbed — the profile entry receives a stub { id } so formatUserDisplay falls back to truncated UUID. This prevents a single missing profile from breaking the entire batch.

`formatUserDisplay(profiles, userId)`

Returns the best available display string for a user, following the priority chain:

v|handle  →  displayName  →  'Mallnline User'

import { formatUserDisplay } from '$lib/utils/profileResolver';

formatUserDisplay(profiles, 'uuid-1');
// → "v|meekdenzo"      (if handle exists)
// → "Meek Denzo"       (if only displayName exists)
// → "Mallnline User"   (anonymous fallback — never exposes raw IDs)

`getAvatarInitials(profiles, userId)`

Returns 1–2 uppercase initials from the resolved displayName, or the first character of the userId as fallback.

import { getAvatarInitials } from '$lib/utils/profileResolver';

getAvatarInitials(profiles, 'uuid-1');
// → "MD"   (from "Meek Denzo")
// → "M"    (from "Madonna")
// → "MU"   (anonymous fallback — never derives from userId)

Integration Pattern

Components that display user attribution follow a consistent pattern:

1. Parent resolves profiles after data load

// In the parent panel/page (e.g., CollaboratorsPanel.svelte)
import { resolveUserProfiles, type ProfileMap } from '$lib/utils/profileResolver';

let profiles: ProfileMap = $state({});

async function fetchData() {
  const data = await client.request(QUERY);
  const userIds = data.items.map(item => item.userId);
  profiles = await resolveUserProfiles(userIds, profiles);
}

2. Child receives profiles as prop

// In the child card (e.g., CollaboratorCard.svelte)
import { formatUserDisplay, getAvatarInitials, type ProfileMap } from '$lib/utils/profileResolver';

let { memberProfiles = {} }: { memberProfiles?: ProfileMap } = $props();

3. Template renders resolved names

<div class="avatar">{getAvatarInitials(memberProfiles, collaborator.userId)}</div>
<strong>{formatUserDisplay(memberProfiles, collaborator.userId)}</strong>

Components Using Profile Resolution

Relationship to Existing Resolution

The org manage page (/orgs/[slug]/manage) already had a local resolveMemberProfiles() function and getMemberDisplayName() helper. The new profileResolver.ts utility is the extracted, centralized version of this pattern. The manage page's existing implementation remains in place (it predated the utility), but all new components should import from profileResolver.ts.

Migration Path

Existing resolution code in the org manage page can optionally be refactored to use profileResolver.ts:

- import { GET_USER_BY_ID, type UserProfileInfo } from '$lib/queries/auth';
+ import { resolveUserProfiles, formatUserDisplay, type ProfileMap } from '$lib/utils/profileResolver';

- async function resolveMemberProfiles(members) { ... }
- function getMemberDisplayName(userId) { ... }
+ // Use resolveUserProfiles() and formatUserDisplay() directly

This is not urgent — the existing code works correctly and the utility is API-compatible.

Security Audit Coverage

The Profile Resolver was created as part of the Raw User ID Exposure Audit (P0 Security). The audit covered 10 frontend sub-areas:

File Reference

Related

• Handle System — Sigil taxonomy (v|handle, r|handle) that the resolver surfaces via formatUserDisplay
• ActorBadge Component System — The UI component that consumes resolved profiles for interactive identity display
• Privacy & Security APIs — Content visibility settings that control what name is shown publicly
• Teams & Sub-Groups — TeamCard and TeamsPanel consume resolved profiles
• Outside Collaborators — CollaboratorCard uses the resolver for external user display
• Platform Admin Provisioning — Tower Team tab uses a similar pattern for admin profile display
• Support Ticket Anonymity — Complementary system that hides real user identity behind aliases in support contexts