@volter/twin-github 2.0.1 → 2.0.2

package/src/semantics/graphql.ts

@@ -284,7 +284,12 @@ export function githubGraphql(): { resolvers: Record<string, FieldResolver>; sto
   };
   return {
     resolvers: {
-      'Query.viewer': (_s, _args, c) => ({ __typename: 'User', login: 'octocat', name: state(c).userProfile.name ?? 'The Octocat' }),
+      // the token's own account; the World's shared token is octocat's, named The Octocat until its profile says otherwise
+      'Query.viewer': (_s, _args, c) => {
+        const login = gh(ctxOf(c)).caller ?? GITHUB_WORLD_USER;
+        const name = state(c).userProfiles[login.toLowerCase()]?.name;
+        return { __typename: 'User', login, name: name ?? (login === GITHUB_WORLD_USER ? 'The Octocat' : null) };
+      },
       'Query.node': queryNode,
       'Query.repository': (_s, args, c) => {
         const repo = `${String(args.owner)}/${String(args.name)}`;
@@ -419,7 +424,7 @@ export function githubGraphql(): { resolvers: Record<string, FieldResolver>; sto
         const login = String(args.login ?? '');
         const st = state(c);
         const known = login === GITHUB_WORLD_USER || st.oauthGrants.some((g) => g.login === login) || st.orgMembers.some((m) => m.login === login) || st.collaborators.some((x) => x.login === login) || st.repos.some((r) => r.owner === login);
-        return known ? { __typename: 'User', login, name: null, id: `U_${login}` } : fail(`Could not resolve to a User with the login of '${login}'.`, 'NOT_FOUND');
+        return known ? { __typename: 'User', login, name: st.userProfiles[login.toLowerCase()]?.name ?? null, id: `U_${login}` } : fail(`Could not resolve to a User with the login of '${login}'.`, 'NOT_FOUND');
       },
       'Query.organization': (_s, args, c) => {
         const org = state(c).orgs.find((o) => o.login === String(args.login ?? ''));

package/src/semantics/shared.ts

@@ -176,6 +176,6 @@ export const writer = (ctx: SemanticsContext): GithubWrite => (w) => put(ctx, w)
  *  the noreply address GitHub gives an account that keeps its email private. */
 export function identityOf(g: Gh): { name: string; email: string } {
   const login = g.caller ?? 'octocat';
-  const profile = login === 'octocat' ? g.state().userProfile : undefined;
+  const profile = g.state().userProfiles[login.toLowerCase()];
   return { name: String(profile?.name ?? login), email: `${twinUserId(login)}+${login}@users.noreply.github.com` };
 }

package/src/semantics/users.ts

@@ -1,13 +1,21 @@
 // GitHub's users family: a user by login or account id, the authenticated user and their profile,
 // the follow graph, emails, SSH and GPG keys, blocks, and the activity streams scoped to a user.
-// The twin models one follow actor, the authenticated `octocat`.
+// Each account's profile and email addresses are its own: GET /user, PATCH /user and /user/emails answer and change the
+// account the request's token names (a personal token, or the token an OAuth app got from the person who consented,
+// src/screens/oauth.tsx); the World's shared token is octocat's. The follow graph is per account too. SSH and GPG keys
+// and blocks are still ONE list whoever asks (todo rows github.users.own_keys, github.users.own_blocks).
 import { me } from './activity.ts';
 import { createHash } from 'node:crypto';
 import type { Semantics } from '@volter/world-core';
 import {
-  githubActivityEvents, githubNotFound, paginate, seedUser, toGithubOrg, toGithubRepo, toGithubUser, toGithubUserEmail, toGithubUserGpgKey, toGithubUserSshKey, toSimpleUser, twinUserId,
+  accountOf, canonicalLogin, emailsOf, githubActivityEvents, githubNotFound, paginate, seedUser, toGithubOrg, toGithubRepo, toGithubUser, toGithubUserEmail, toGithubUserGpgKey, toGithubUserSshKey, toSimpleUser, twinUserId,
 } from '../github-twin.ts';
-import { asView, gh, nextSeq, put, send } from './shared.ts';
+import { asView, atomic, gh, nextSeq, put, send } from './shared.ts';
+
+/** An app's installation token speaks for the app, which has no profile or addresses of its own to change: GitHub
+ *  answers its writes to the authenticated user 403 "Resource not accessible by integration". */
+const asApp = (ctx: Parameters<Semantics>[0]): Response | undefined =>
+  (gh(ctx).caller ?? '').endsWith('[bot]') ? ctx.reply({ message: 'Resource not accessible by integration', documentation_url: 'https://docs.github.com/rest/users/users#update-the-authenticated-user' }, 403) : undefined;
 
 /** GET /users/:login/events[/public] and /users/:login/received_events[/public]: events = activity the
  *  user PERFORMED (actor); received_events = activity in repos the user OWNS. Both filter the SAME
@@ -26,8 +34,9 @@ const userEvents = (received: boolean, only: 'public' | undefined): Semantics =>
 export function usersSemantics(): Record<string, Semantics> {
   const usersGetByUsername: Semantics = async (ctx) => {
     const { seg, state } = gh(ctx);
-    const login = decodeURIComponent(seg[1]!);
-    return ctx.reply(toGithubUser(login === 'octocat' ? { ...seedUser('octocat'), ...state().userProfile, login } : seedUser(login)));
+    // a login in another case names the same account, answered as it is spelled (and with its id)
+    const login = canonicalLogin(decodeURIComponent(seg[1]!), ctx.root);
+    return ctx.reply(toGithubUser(accountOf(state(), login)));
   };
   const reposListForAuthenticatedUser: Semantics = async (ctx) => {
     const { caller, query, state } = gh(ctx);
@@ -94,11 +103,11 @@ export function usersSemantics(): Record<string, Semantics> {
   };
   const usersListEmailsForAuthenticatedUser: Semantics = async (ctx) => {
     const { query, state } = gh(ctx);
-    return ctx.reply(paginate(state().userEmails, query).map(toGithubUserEmail));
+    return ctx.reply(paginate(emailsOf(state(), me(ctx)), query).map(toGithubUserEmail));
   };
   const usersListPublicEmailsForAuthenticatedUser: Semantics = async (ctx) => {
     const { query, state } = gh(ctx);
-    return ctx.reply(paginate(state().userEmails.filter((e) => e.visibility === 'public'), query).map(toGithubUserEmail));
+    return ctx.reply(paginate(emailsOf(state(), me(ctx)).filter((e) => e.visibility === 'public'), query).map(toGithubUserEmail));
   };
   const usersListPublicSshKeysForAuthenticatedUser: Semantics = async (ctx) => {
     const { query, state } = gh(ctx);
@@ -127,16 +136,25 @@ export function usersSemantics(): Record<string, Semantics> {
     return send(ctx, state().blockedUsers.has(decodeURIComponent(seg[2]!)) ? { status: 204, body: undefined } : githubNotFound());
   };
   const usersGetAuthenticated: Semantics = async (ctx) => {
-    const { caller, state } = gh(ctx);
-    if (caller) return ctx.reply(toGithubUser(seedUser(caller)));
-    return ctx.reply(toGithubUser({ ...seedUser('octocat'), ...state().userProfile, login: 'octocat' }));
+    const { state } = gh(ctx);
+    return ctx.reply(toGithubUser(accountOf(state(), me(ctx))));
   };
   const usersUpdateAuthenticated: Semantics = async (ctx) => {
+    const refused = asApp(ctx);
+    if (refused) return refused;
     const { body, state } = gh(ctx);
     const fields: Record<string, unknown> = {};
     for (const k of ['name', 'bio', 'company', 'blog', 'location', 'email'] as const) if (body[k] !== undefined) fields[k] = body[k];
-    await put(ctx, { operation: 'user_profile.update', subjectType: 'user_profile', subjectId: 'user_profile:octocat', fields });
-    return ctx.reply(toGithubUser({ ...seedUser('octocat'), ...state().userProfile, login: 'octocat' }));
+    const login = me(ctx);
+    // the public email is one of the account's own verified addresses (GitHub's profile settings offer only those; the
+    // REST docs name the field "The publicly visible email address of the user" and a 422 for a validation failure);
+    // empty or null shows none. The 422's wording is the twin's.
+    if (typeof fields.email === 'string' && fields.email !== '' && !emailsOf(state(), login).some((e) => e.verified && e.email.toLowerCase() === String(fields.email).toLowerCase())) {
+      return ctx.reply({ message: 'Validation Failed', errors: [{ resource: 'User', code: 'custom', field: 'email', message: 'email must be one of your verified email addresses' }], documentation_url: 'https://docs.github.com/rest/users/users#update-the-authenticated-user' }, 422);
+    }
+    if (fields.email !== undefined && fields.email !== null && typeof fields.email !== 'string') return ctx.reply({ message: 'Validation Failed', errors: [{ resource: 'User', code: 'invalid', field: 'email' }] }, 422);
+    await put(ctx, { operation: 'user_profile.update', subjectType: 'user_profile', subjectId: `user_profile:${login.toLowerCase()}`, fields: { ...fields, login } });
+    return ctx.reply(toGithubUser(accountOf(state(), login)));
   };
   const usersCreatePublicSshKeyForAuthenticatedUser: Semantics = async (ctx) => {
     const { body, occurredAt, state } = gh(ctx);
@@ -201,11 +219,12 @@ export function usersSemantics(): Record<string, Semantics> {
     'users/list-blocked-by-authenticated-user': usersListBlockedByAuthenticatedUser,
     // "Check if a user is blocked by the authenticated user" → 204 blocked / 404 not.
     'users/check-blocked': usersCheckBlocked,
-    // the token's own user when the twin's user door minted it; else the deterministic octocat
+    // the token's own account (a personal token, an OAuth app's token for the person who consented) under the
+    // profile that person edited; the World's shared token is octocat's
     'users/get-authenticated': usersGetAuthenticated,
     'users/update-authenticated': usersUpdateAuthenticated,
-    'users/add-email-for-authenticated-user': async (ctx) => emails(ctx, false),
-    'users/delete-email-for-authenticated-user': async (ctx) => emails(ctx, true),
+    'users/add-email-for-authenticated-user': async (ctx) => asApp(ctx) ?? emails(ctx, false),
+    'users/delete-email-for-authenticated-user': async (ctx) => asApp(ctx) ?? emails(ctx, true),
     'users/create-public-ssh-key-for-authenticated-user': usersCreatePublicSshKeyForAuthenticatedUser,
     'users/delete-public-ssh-key-for-authenticated-user': usersDeletePublicSshKeyForAuthenticatedUser,
     'users/create-gpg-key-for-authenticated-user': usersCreateGpgKeyForAuthenticatedUser,
@@ -219,24 +238,45 @@ export function usersSemantics(): Record<string, Semantics> {
   };
 }
 
-/** POST /user/emails adds, DELETE removes; both take `{emails}` or a bare array. The first address a
- *  user adds is primary and public. */
+/** POST /user/emails adds, DELETE removes, on the caller's own account; both take `{emails}` or a bare array. The
+ *  first address an account adds is primary and public. An address is one account's: adding one another account holds
+ *  is refused (422, the twin's wording: GitHub's docs name only the status), each address checked and claimed in one
+ *  atomic step, and removing one leaves every other account's addresses alone. The primary address is not removed
+ *  (422): GitHub has its person make another address primary first (github.com/orgs/community/discussions/62557; the
+ *  wording is the twin's). */
 async function emails(ctx: Parameters<Semantics>[0], remove: boolean): Promise<Response> {
   const { body, state } = gh(ctx);
+  const login = me(ctx);
   const list: string[] = Array.isArray(body.emails) ? body.emails.map(String) : Array.isArray(body) ? (body as string[]).map(String) : [];
   if (!list.length) return ctx.reply({ message: 'Validation Failed', errors: [{ resource: 'Email', field: 'emails', code: 'missing_field' }] }, 422);
   const st = state();
+  const mine = (e: { login: string }) => e.login.toLowerCase() === login.toLowerCase();
+  const held = (email: string) => st.userEmails.find((e) => e.email.toLowerCase() === email.toLowerCase());
+  if (!remove && list.some((email) => { const h = held(email); return h && !mine(h); })) {
+    return ctx.reply({ message: 'Validation Failed', errors: [{ resource: 'UserEmail', code: 'custom', field: 'email', message: 'email is already in use' }] }, 422);
+  }
+  if (remove && list.some((email) => { const h = held(email); return h && mine(h) && h.primary; })) {
+    return ctx.reply({ message: 'Validation Failed', errors: [{ resource: 'UserEmail', code: 'custom', field: 'email', message: 'the primary email address cannot be removed' }] }, 422);
+  }
+  const hadNone = emailsOf(st, login).length === 0;
+  const claim = atomic(ctx);
   for (const email of list) {
-    const subjectId = `useremail:${email}`;
+    const h = held(email);
+    const subjectId = `useremail:${h?.email ?? email}`;
     if (remove) {
-      await put(ctx, { operation: 'user_email.delete', subjectType: 'user_email', subjectId, fields: { deleted: true, email } });
-    } else {
-      const isFirst = st.userEmails.length === 0 && email === list[0];
-      await put(ctx, { operation: 'user_email.upsert', subjectType: 'user_email', subjectId, fields: { email, primary: isFirst, verified: true, visibility: isFirst ? 'public' : 'private' } });
+      if (h && mine(h)) await put(ctx, { operation: 'user_email.delete', subjectType: 'user_email', subjectId, fields: { deleted: true, email: h.email } });
+    } else if (!h) {
+      const isFirst = hadNone && email === list[0];
+      const lost = await claim(() => {
+        const now = state().userEmails.find((e) => e.email.toLowerCase() === email.toLowerCase());
+        if (now) return { value: !mine(now) };
+        return { value: false, write: { operation: 'user_email.upsert', subjectType: 'user_email', subjectId, fields: { email, primary: isFirst, verified: true, visibility: isFirst ? 'public' : 'private', login } } };
+      });
+      if (lost) return ctx.reply({ message: 'Validation Failed', errors: [{ resource: 'UserEmail', code: 'custom', field: 'email', message: 'email is already in use' }] }, 422);
     }
   }
   if (remove) return send(ctx, { status: 204, body: undefined });
-  return ctx.reply(state().userEmails.map(toGithubUserEmail), 201);
+  return ctx.reply(emailsOf(state(), login).map(toGithubUserEmail), 201);
 }
 
 async function block(ctx: Parameters<Semantics>[0], blocking: boolean): Promise<Response> {