@volter/twin-github 0.1.2 → 2.0.1

package/dist/src/semantics/orgs.js

@@ -0,0 +1,420 @@
+import { GITHUB_WORLD_USER, githubNotFound, paginate, seedUser, toGithubIssueType, toGithubOrg, toGithubOrgMembership, toGithubOrgWebhook, toGithubRepo, toGithubTeam, toGithubTeamMembership, toGithubUser, twinUserId } from "../github-twin.js";
+import { asView, gh, nextSeq, put, send } from "./shared.js";
+const invalid = (ctx, resource, field, code, documentation_url) => ctx.reply({ message: 'Validation Failed', errors: [{ resource, field, code }], ...(documentation_url ? { documentation_url } : {}) }, 422);
+// GitHub's team-name → slug derivation (lowercase, non-alphanum → '-', collapse/trim dashes).
+function slugifyTeamName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').replace(/-+/g, '-');
+}
+/** The team a path under /orgs/:org/teams/:slug names, or nothing. */
+function teamOf(g) {
+    const org = decodeURIComponent(g.seg[1]);
+    const slug = decodeURIComponent(g.seg[3]);
+    return { org, slug, team: g.state().teams.find((t) => t.org === org && t.slug === slug) };
+}
+/** A read or write under a team: Not Found when the team does not exist. */
+const underTeam = (serve) => async (ctx) => {
+    const g = gh(ctx);
+    const { org, slug, team } = teamOf(g);
+    return team ? serve(ctx, g, org, slug, team) : send(ctx, githubNotFound());
+};
+async function removeOrgMember(ctx) {
+    const { seg, state } = gh(ctx);
+    const org = decodeURIComponent(seg[1]);
+    const login = decodeURIComponent(seg[3]);
+    if (!state().orgMembers.some((m) => m.org === org && m.login === login))
+        return send(ctx, githubNotFound());
+    await put(ctx, { operation: 'org_membership.remove', subjectType: 'org_membership', subjectId: `orgmember:${org}#${login}`, fields: { deleted: true, org, login } });
+    return send(ctx, { status: 204, body: undefined });
+}
+/** Edit an issue type (GitHub's PUT; the hand-written route keeps the PATCH it also answered). */
+async function updateIssueType(ctx) {
+    const { seg, body, occurredAt, state } = gh(ctx);
+    const org = decodeURIComponent(seg[1]);
+    const id = Number(decodeURIComponent(seg[3]));
+    const existing = state().issueTypes.find((t) => t.org === org && t.id === id);
+    if (!existing)
+        return send(ctx, githubNotFound());
+    // the update is a PUT: name and is_enabled are required, as on create (docs.github.com/rest/orgs/issue-types)
+    if (!body.name)
+        return invalid(ctx, 'IssueType', 'name', 'missing_field');
+    if (typeof body.is_enabled !== 'boolean')
+        return invalid(ctx, 'IssueType', 'is_enabled', 'missing_field');
+    const fields = { org, name: existing.name, description: existing.description, color: existing.color, is_enabled: existing.is_enabled, created_at: existing.created_at, updated_at: occurredAt };
+    for (const k of ['name', 'description', 'color'])
+        if (body[k] !== undefined)
+            fields[k] = body[k];
+    if (body.is_enabled !== undefined)
+        fields.is_enabled = body.is_enabled !== false;
+    await put(ctx, { operation: 'issue_type.update', subjectType: 'issue_type', subjectId: `issuetype:${id}`, fields });
+    return ctx.reply(toGithubIssueType(state().issueTypes.find((x) => x.org === org && x.id === id)));
+}
+/** An organization's outside collaborators: people with access to one of its repositories who are not its members,
+ *  and members it converted (docs.github.com/organizations/managing-user-access-to-your-organizations-repositories). */
+function outsideOf(st, org) {
+    const members = new Set(st.orgMembers.filter((m) => m.org === org && m.state === 'active').map((m) => m.login));
+    const logins = new Set([...st.outsideCollaborators.filter((c) => c.org === org).map((c) => c.login), ...st.collaborators.filter((c) => c.repository.startsWith(`${org}/`)).map((c) => c.login)]);
+    return [...logins].filter((l) => !members.has(l)).sort();
+}
+export function orgsSemantics() {
+    const orgsGet = async (ctx) => {
+        const { seg, caller, state } = gh(ctx);
+        const login = decodeURIComponent(seg[1]);
+        const st = state();
+        const o = st.orgs.find((x) => x.login === login);
+        if (!o)
+            return send(ctx, githubNotFound());
+        // GitHub reports the two-factor requirement only to the organization's owners.
+        const owner = !!caller && st.orgMembers.some((m) => m.org === login && m.login === caller && m.role === 'admin' && (m.state ?? 'active') === 'active');
+        return ctx.reply({ ...toGithubOrg(o, st), ...(owner ? { two_factor_requirement_enabled: o.two_factor_requirement_enabled === true } : {}) });
+    };
+    const orgsUpdate = async (ctx) => {
+        const { seg, body, occurredAt, state } = gh(ctx);
+        const login = decodeURIComponent(seg[1]);
+        const prev = state().orgs.find((o) => o.login === login);
+        // an organization is created on github.com (the twin's door, POST /_twin/orgs), never by an edit
+        if (!prev)
+            return send(ctx, githubNotFound());
+        const fields = { login, updated_at: occurredAt, created_at: prev.created_at ?? occurredAt };
+        for (const k of ['description', 'name', 'company', 'blog', 'location', 'email', 'billing_email'])
+            if (body[k] !== undefined)
+                fields[k] = body[k];
+        await put(ctx, { operation: 'organization.update', subjectType: 'organization', subjectId: `org:${login}`, fields });
+        return ctx.reply(toGithubOrg(state().orgs.find((x) => x.login === login), state()));
+    };
+    const orgsListMembers = async (ctx) => {
+        const { seg, query, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const role = new URLSearchParams((query ?? '').replace(/^\?/, '')).get('role') ?? 'all';
+        if (!['all', 'admin', 'member'].includes(role))
+            return invalid(ctx, 'Organization', 'role', 'invalid', 'https://docs.github.com/rest/orgs/members#list-organization-members');
+        const members = state().orgMembers.filter((m) => m.org === org && m.state === 'active' && (role === 'all' || m.role === role));
+        return ctx.reply(paginate(members, query).map((m) => asView('simple-user', toGithubUser(seedUser(m.login)))));
+    };
+    const orgsCheckMembershipForUser = async (ctx) => {
+        const { seg, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const m = state().orgMembers.find((x) => x.org === org && x.login === decodeURIComponent(seg[3]) && x.state === 'active');
+        return send(ctx, m ? { status: 204, body: undefined } : githubNotFound());
+    };
+    const orgsGetMembershipForUser = async (ctx) => {
+        const { seg, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const login = decodeURIComponent(seg[3]);
+        const m = state().orgMembers.find((x) => x.org === org && x.login === login);
+        return send(ctx, m ? { status: 200, body: toGithubOrgMembership(m) } : githubNotFound());
+    };
+    const orgsListPendingInvitations = async (ctx) => {
+        const { seg, query, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const pending = state().orgMembers.filter((m) => m.org === org && m.state === 'pending');
+        return ctx.reply(paginate(pending, query).map((m) => ({
+            id: twinUserId(`${org}#${m.login}`), node_id: null, login: m.login, email: null, role: m.role === 'admin' ? 'admin' : 'direct_member',
+            created_at: m.created_at ?? null, failed_at: null, failed_reason: null, inviter: toGithubUser(seedUser(GITHUB_WORLD_USER)), team_count: 0,
+            invitation_teams_url: `https://api.github.com/organizations/${org}/invitations/${m.login}/teams`, invitation_source: 'member',
+        })));
+    };
+    const orgsListMembershipsForAuthenticatedUser = async (ctx) => {
+        const { caller, query, state } = gh(ctx);
+        const me = caller ?? GITHUB_WORLD_USER;
+        const wanted = new URLSearchParams((query ?? '').replace(/^\?/, '')).get('state');
+        return ctx.reply(paginate(state().orgMembers.filter((m) => m.login === me && (!wanted || m.state === wanted)), query).map(toGithubOrgMembership));
+    };
+    const orgsGetMembershipForAuthenticatedUser = async (ctx) => {
+        const { caller, seg, state } = gh(ctx);
+        const org = decodeURIComponent(seg[3]);
+        const m = state().orgMembers.find((x) => x.org === org && x.login === (caller ?? GITHUB_WORLD_USER));
+        return send(ctx, m ? { status: 200, body: toGithubOrgMembership(m) } : githubNotFound());
+    };
+    const orgsListOutsideCollaborators = async (ctx) => {
+        const { seg, query, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        return ctx.reply(paginate(outsideOf(state(), org), query).map((login) => asView('simple-user', toGithubUser(seedUser(login)))));
+    };
+    const orgsConvertMemberToOutsideCollaborator = async (ctx) => {
+        const { seg } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const login = decodeURIComponent(seg[3]);
+        await put(ctx, { operation: 'outside_collaborator.add', subjectType: 'outside_collaborator', subjectId: `outsidecollab:${org}#${login}`, fields: { org, login } });
+        // they are no longer a member, nor on its teams; the repositories they worked in stay theirs
+        const st = gh(ctx).state();
+        const membership = st.orgMembers.find((m) => m.org === org && m.login === login);
+        if (membership)
+            await put(ctx, { operation: 'org_membership.remove', subjectType: 'org_membership', subjectId: `orgmember:${org}#${login}`, fields: { ...membership, deleted: true } });
+        for (const t of st.teamMembers.filter((m) => m.org === org && m.login === login)) {
+            await put(ctx, { operation: 'team_membership.remove', subjectType: 'team_membership', subjectId: `teammember:${org}#${t.team_slug}#${login}`, fields: { ...t, deleted: true } });
+        }
+        return send(ctx, { status: 204, body: undefined });
+    };
+    const orgsRemoveOutsideCollaborator = async (ctx) => {
+        const { seg, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const login = decodeURIComponent(seg[3]);
+        const st = state();
+        if (!outsideOf(st, org).includes(login))
+            return send(ctx, githubNotFound());
+        if (st.outsideCollaborators.some((c) => c.org === org && c.login === login))
+            await put(ctx, { operation: 'outside_collaborator.remove', subjectType: 'outside_collaborator', subjectId: `outsidecollab:${org}#${login}`, fields: { deleted: true, org, login } });
+        for (const c of st.collaborators.filter((x) => x.login === login && x.repository.startsWith(`${org}/`))) {
+            await put(ctx, { operation: 'collaborator.remove', subjectType: 'collaborator', subjectId: `collab:${c.repository}#${login}`, fields: { deleted: true, repository: c.repository, login } });
+        }
+        return send(ctx, { status: 204, body: undefined });
+    };
+    const orgsListWebhooks = async (ctx) => {
+        const { seg, query, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        return ctx.reply(paginate(state().orgWebhooks.filter((h) => h.org === org), query).map(toGithubOrgWebhook));
+    };
+    const orgsGetWebhook = async (ctx) => {
+        const { seg, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const h = state().orgWebhooks.find((x) => x.org === org && x.id === Number(decodeURIComponent(seg[3])));
+        return send(ctx, h ? { status: 200, body: toGithubOrgWebhook(h) } : githubNotFound());
+    };
+    const orgsCreateWebhook = async (ctx) => {
+        const { seg, body, occurredAt, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const cfg = (body.config ?? {});
+        if (!cfg.url)
+            return invalid(ctx, 'Hook', 'config', 'missing_field');
+        const seq = nextSeq(ctx, 'orghook');
+        const fields = { org, active: body.active !== false, events: Array.isArray(body.events) ? body.events : ['push'], url: String(cfg.url), content_type: cfg.content_type ?? 'form', created_at: occurredAt, updated_at: occurredAt };
+        await put(ctx, { operation: 'org_webhook.create', subjectType: 'org_webhook', subjectId: `orghook:${seq}`, fields });
+        return ctx.reply(toGithubOrgWebhook(state().orgWebhooks.find((x) => x.org === org && x.id === seq)), 201);
+    };
+    const orgsUpdateWebhook = async (ctx) => {
+        const { seg, body, occurredAt, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const id = Number(decodeURIComponent(seg[3]));
+        const existing = state().orgWebhooks.find((h) => h.org === org && h.id === id);
+        if (!existing)
+            return send(ctx, githubNotFound());
+        const cfg = (body.config ?? {});
+        const fields = { org, created_at: existing.created_at, updated_at: occurredAt, url: existing.url, content_type: existing.content_type, events: existing.events, active: existing.active };
+        if (body.active !== undefined)
+            fields.active = body.active !== false;
+        if (Array.isArray(body.events))
+            fields.events = body.events;
+        if (cfg.url !== undefined)
+            fields.url = String(cfg.url);
+        if (cfg.content_type !== undefined)
+            fields.content_type = cfg.content_type;
+        await put(ctx, { operation: 'org_webhook.update', subjectType: 'org_webhook', subjectId: `orghook:${id}`, fields });
+        return ctx.reply(toGithubOrgWebhook(state().orgWebhooks.find((x) => x.org === org && x.id === id)));
+    };
+    const orgsDeleteWebhook = async (ctx) => {
+        const { seg, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const id = Number(decodeURIComponent(seg[3]));
+        if (!state().orgWebhooks.find((h) => h.org === org && h.id === id))
+            return send(ctx, githubNotFound());
+        await put(ctx, { operation: 'org_webhook.delete', subjectType: 'org_webhook', subjectId: `orghook:${id}`, fields: { deleted: true, org } });
+        return send(ctx, { status: 204, body: undefined });
+    };
+    const orgsListIssueTypes = async (ctx) => {
+        const { seg, query, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        return ctx.reply(paginate(state().issueTypes.filter((t) => t.org === org), query).map(toGithubIssueType));
+    };
+    const orgsCreateIssueType = async (ctx) => {
+        const { seg, body, occurredAt, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        // name and is_enabled are required (docs.github.com/rest/orgs/issue-types#create-issue-type-for-an-organization)
+        if (!body.name)
+            return invalid(ctx, 'IssueType', 'name', 'missing_field');
+        if (typeof body.is_enabled !== 'boolean')
+            return invalid(ctx, 'IssueType', 'is_enabled', 'missing_field');
+        if (state().issueTypes.some((t) => t.org === org && t.name === String(body.name)))
+            return invalid(ctx, 'IssueType', 'name', 'already_exists');
+        const seq = nextSeq(ctx, 'issuetype');
+        const fields = { org, name: String(body.name), description: body.description ?? null, color: body.color ?? null, is_enabled: body.is_enabled, created_at: occurredAt, updated_at: occurredAt };
+        await put(ctx, { operation: 'issue_type.create', subjectType: 'issue_type', subjectId: `issuetype:${seq}`, fields });
+        return ctx.reply(toGithubIssueType(state().issueTypes.find((x) => x.org === org && x.name === String(body.name))));
+    };
+    const orgsDeleteIssueType = async (ctx) => {
+        const { seg, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const id = Number(decodeURIComponent(seg[3]));
+        if (!state().issueTypes.find((t) => t.org === org && t.id === id))
+            return send(ctx, githubNotFound());
+        await put(ctx, { operation: 'issue_type.delete', subjectType: 'issue_type', subjectId: `issuetype:${id}`, fields: { deleted: true, org } });
+        return send(ctx, { status: 204, body: undefined });
+    };
+    const reposListForOrg = async (ctx) => {
+        const { seg, query, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        const params = new URLSearchParams((query ?? '').replace(/^\?/, ''));
+        let items = state().repos.filter((r) => r.owner === org);
+        const type = params.get('type');
+        if (type === 'public')
+            items = items.filter((r) => !(r.private ?? false));
+        else if (type === 'private')
+            items = items.filter((r) => r.private ?? false);
+        else if (type === 'forks')
+            items = items.filter((r) => r.fork ?? false);
+        else if (type === 'sources')
+            items = items.filter((r) => !(r.fork ?? false));
+        const sort = params.get('sort');
+        if (sort === 'full_name')
+            items = [...items].sort((a, b) => (a.full_name < b.full_name ? -1 : 1));
+        else if (sort === 'created')
+            items = [...items].sort((a, b) => ((a.created_at ?? '') < (b.created_at ?? '') ? 1 : -1));
+        else if (sort === 'updated')
+            items = [...items].sort((a, b) => ((a.updated_at ?? '') < (b.updated_at ?? '') ? 1 : -1));
+        return ctx.reply(paginate(items, query).map(toGithubRepo));
+    };
+    const teamsList = async (ctx) => {
+        const { seg, query, state } = gh(ctx);
+        const org = decodeURIComponent(seg[1]);
+        return ctx.reply(paginate(state().teams.filter((t) => t.org === org), query).map((t) => asView('team', toGithubTeam(t))));
+    };
+    const teamsUpdateInOrg = (ctx) => (underTeam(async (ctx, g, org, slug, existing) => {
+        const fields = { org, slug, name: existing.name, description: existing.description, privacy: existing.privacy, permission: existing.permission, created_at: existing.created_at, updated_at: g.occurredAt };
+        for (const k of ['name', 'description', 'privacy', 'permission'])
+            if (g.body[k] !== undefined)
+                fields[k] = g.body[k];
+        await put(ctx, { operation: 'team.update', subjectType: 'team', subjectId: `team:${existing.id}`, fields });
+        return ctx.reply(toGithubTeam(g.state().teams.find((x) => x.org === org && x.slug === slug), g.state()));
+    }))(ctx);
+    const teamsDeleteInOrg = (ctx) => (underTeam(async (ctx, _g, org, _slug, existing) => {
+        await put(ctx, { operation: 'team.delete', subjectType: 'team', subjectId: `team:${existing.id}`, fields: { deleted: true, org } });
+        return send(ctx, { status: 204, body: undefined });
+    }))(ctx);
+    const teamsListMembersInOrg = (ctx) => (underTeam(async (ctx, g, org, slug) => {
+        const role = new URLSearchParams((g.query ?? '').replace(/^\?/, '')).get('role') ?? 'all';
+        if (!['all', 'member', 'maintainer'].includes(role))
+            return invalid(ctx, 'Team', 'role', 'invalid', 'https://docs.github.com/rest/teams/members#list-team-members');
+        const members = g.state().teamMembers.filter((m) => m.org === org && m.team_slug === slug && (m.state ?? 'active') === 'active' && (role === 'all' || m.role === role));
+        return ctx.reply(paginate(members, g.query).map((m) => asView('team-member', toGithubUser(seedUser(m.login)))));
+    }))(ctx);
+    const teamsRemoveMembershipForUserInOrg = (ctx) => (underTeam(async (ctx, g, org, slug) => {
+        const login = decodeURIComponent(g.seg[5]);
+        if (!g.state().teamMembers.some((m) => m.org === org && m.team_slug === slug && m.login === login))
+            return send(ctx, githubNotFound());
+        await put(ctx, { operation: 'team_membership.remove', subjectType: 'team_membership', subjectId: `teammember:${org}#${slug}#${login}`, fields: { deleted: true, org, team_slug: slug, login } });
+        return send(ctx, { status: 204, body: undefined });
+    }))(ctx);
+    const teamsListReposInOrg = (ctx) => (underTeam(async (ctx, g, org, slug) => {
+        const st = g.state();
+        const items = st.teamRepos.filter((x) => x.org === org && x.team_slug === slug).map((t) => st.repos.find((r) => r.full_name === t.repository)).filter((r) => !!r);
+        return ctx.reply(paginate(items, g.query).map(toGithubRepo));
+    }))(ctx);
+    const teamsCheckPermissionsForRepoInOrg = (ctx) => (underTeam(async (ctx, g, org, slug) => {
+        const repo = `${decodeURIComponent(g.seg[5])}/${decodeURIComponent(g.seg[6])}`;
+        return send(ctx, g.state().teamRepos.find((x) => x.org === org && x.team_slug === slug && x.repository === repo) ? { status: 204, body: undefined } : githubNotFound());
+    }))(ctx);
+    const teamsRemoveRepoInOrg = (ctx) => (underTeam(async (ctx, g, org, slug) => {
+        const repo = `${decodeURIComponent(g.seg[5])}/${decodeURIComponent(g.seg[6])}`;
+        if (!g.state().teamRepos.some((x) => x.org === org && x.team_slug === slug && x.repository === repo))
+            return send(ctx, githubNotFound());
+        await put(ctx, { operation: 'team_repo.remove', subjectType: 'team_repo', subjectId: `teamrepo:${org}#${slug}#${repo}`, fields: { deleted: true, org, team_slug: slug, repository: repo } });
+        return send(ctx, { status: 204, body: undefined });
+    }))(ctx);
+    return {
+        'orgs/get': orgsGet,
+        'orgs/update': orgsUpdate,
+        // `role` filters as GitHub does: all (the default), admin or member; any other value is a validation error.
+        'orgs/list-members': orgsListMembers,
+        // 204 member / 404 not
+        'orgs/check-membership-for-user': orgsCheckMembershipForUser,
+        'orgs/remove-member': removeOrgMember,
+        'orgs/get-membership-for-user': orgsGetMembershipForUser,
+        // Invite or set a role (docs.github.com/rest/orgs/members#set-organization-membership-for-a-user): someone not
+        // yet a member is invited, pending until they accept (PATCH /user/memberships/orgs/{org}); a member's role
+        // changes in place.
+        'orgs/set-membership-for-user': async (ctx) => {
+            const { seg, body, occurredAt, state } = gh(ctx);
+            const org = decodeURIComponent(seg[1]);
+            const login = decodeURIComponent(seg[3]);
+            if (body.role !== undefined && body.role !== 'admin' && body.role !== 'member')
+                return invalid(ctx, 'Membership', 'role', 'invalid', 'https://docs.github.com/rest/orgs/members#set-organization-membership-for-a-user');
+            const role = body.role === 'admin' ? 'admin' : 'member';
+            const prior = state().orgMembers.find((x) => x.org === org && x.login === login);
+            await put(ctx, { operation: 'org_membership.upsert', subjectType: 'org_membership', subjectId: `orgmember:${org}#${login}`, fields: { org, login, role, state: prior?.state ?? 'pending', created_at: prior?.created_at ?? occurredAt } });
+            return ctx.reply(toGithubOrgMembership(state().orgMembers.find((x) => x.org === org && x.login === login)));
+        },
+        // the invitations waiting on their invitee (docs.github.com/rest/orgs/members#list-pending-organization-invitations)
+        'orgs/list-pending-invitations': orgsListPendingInvitations,
+        // the signed-in person's own memberships, and accepting an invitation: state 'active' is the only one accepted
+        // (docs.github.com/rest/orgs/members#update-an-organization-membership-for-the-authenticated-user)
+        'orgs/list-memberships-for-authenticated-user': orgsListMembershipsForAuthenticatedUser,
+        'orgs/get-membership-for-authenticated-user': orgsGetMembershipForAuthenticatedUser,
+        'orgs/update-membership-for-authenticated-user': async (ctx) => {
+            const { caller, seg, body, state } = gh(ctx);
+            const org = decodeURIComponent(seg[3]);
+            const me = caller ?? GITHUB_WORLD_USER;
+            const m = state().orgMembers.find((x) => x.org === org && x.login === me);
+            if (!m)
+                return send(ctx, githubNotFound());
+            if (body.state !== 'active')
+                return invalid(ctx, 'Membership', 'state', 'invalid', 'https://docs.github.com/rest/orgs/members#update-an-organization-membership-for-the-authenticated-user');
+            await put(ctx, { operation: 'org_membership.upsert', subjectType: 'org_membership', subjectId: `orgmember:${org}#${me}`, fields: { ...m, state: 'active' } });
+            // the teams they were invited to take them in with the organization
+            for (const t of state().teamMembers.filter((x) => x.org === org && x.login === me && x.state === 'pending')) {
+                await put(ctx, { operation: 'team_membership.upsert', subjectType: 'team_membership', subjectId: `teammember:${org}#${t.team_slug}#${me}`, fields: { ...t, state: 'active' } });
+            }
+            return ctx.reply(toGithubOrgMembership(state().orgMembers.find((x) => x.org === org && x.login === me)));
+        },
+        'orgs/remove-membership-for-user': removeOrgMember,
+        'orgs/list-outside-collaborators': orgsListOutsideCollaborators,
+        'orgs/convert-member-to-outside-collaborator': orgsConvertMemberToOutsideCollaborator,
+        // removing an outside collaborator takes away their access to every repository of the organization
+        'orgs/remove-outside-collaborator': orgsRemoveOutsideCollaborator,
+        'orgs/list-webhooks': orgsListWebhooks,
+        'orgs/get-webhook': orgsGetWebhook,
+        'orgs/create-webhook': orgsCreateWebhook,
+        'orgs/update-webhook': orgsUpdateWebhook,
+        'orgs/delete-webhook': orgsDeleteWebhook,
+        'orgs/list-issue-types': orgsListIssueTypes,
+        'orgs/create-issue-type': orgsCreateIssueType,
+        'orgs/update-issue-type': updateIssueType,
+        'orgs/delete-issue-type': orgsDeleteIssueType,
+        // repositories an org owns; ?type=(all|public|private|forks|sources) and ?sort=(created|updated|full_name)
+        'repos/list-for-org': reposListForOrg,
+        // ── teams ──
+        'teams/list': teamsList,
+        'teams/get-by-name': underTeam(async (ctx, g, _org, _slug, team) => ctx.reply(toGithubTeam(team, g.state()))),
+        'teams/create': async (ctx) => {
+            const { seg, body, occurredAt, state } = gh(ctx);
+            const org = decodeURIComponent(seg[1]);
+            if (!body.name)
+                return invalid(ctx, 'Team', 'name', 'missing_field');
+            const slug = slugifyTeamName(String(body.name));
+            if (state().teams.some((t) => t.org === org && t.slug === slug))
+                return invalid(ctx, 'Team', 'name', 'already_exists');
+            const seq = nextSeq(ctx, 'team');
+            const fields = { org, slug, name: String(body.name), description: body.description ?? null, privacy: body.privacy ?? 'secret', permission: body.permission ?? 'pull', created_at: occurredAt, updated_at: occurredAt };
+            await put(ctx, { operation: 'team.create', subjectType: 'team', subjectId: `team:${seq}`, fields });
+            return ctx.reply(toGithubTeam(state().teams.find((x) => x.org === org && x.slug === slug), state()), 201);
+        },
+        'teams/update-in-org': teamsUpdateInOrg,
+        'teams/delete-in-org': teamsDeleteInOrg,
+        // `role` filters as GitHub does: all (the default), member or maintainer; only active memberships are listed.
+        'teams/list-members-in-org': teamsListMembersInOrg,
+        'teams/get-membership-for-user-in-org': underTeam(async (ctx, g, org, slug) => {
+            const m = g.state().teamMembers.find((x) => x.org === org && x.team_slug === slug && x.login === decodeURIComponent(g.seg[5]));
+            return send(ctx, m ? { status: 200, body: toGithubTeamMembership(m, g.state()) } : githubNotFound());
+        }),
+        'teams/add-or-update-membership-for-user-in-org': underTeam(async (ctx, g, org, slug) => {
+            const login = decodeURIComponent(g.seg[5]);
+            const role = g.body.role === 'maintainer' ? 'maintainer' : 'member';
+            // someone not yet in the organization is invited to it, and their team membership is pending until they accept
+            // (docs.github.com/rest/teams/members#add-or-update-team-membership-for-a-user)
+            const membership = g.state().orgMembers.find((m) => m.org === org && m.login === login);
+            if (!membership)
+                await put(ctx, { operation: 'org_membership.upsert', subjectType: 'org_membership', subjectId: `orgmember:${org}#${login}`, fields: { org, login, role: 'member', state: 'pending', created_at: g.occurredAt } });
+            const state = membership?.state === 'active' ? 'active' : 'pending';
+            await put(ctx, { operation: 'team_membership.upsert', subjectType: 'team_membership', subjectId: `teammember:${org}#${slug}#${login}`, fields: { org, team_slug: slug, login, role, state } });
+            return ctx.reply(toGithubTeamMembership(g.state().teamMembers.find((x) => x.org === org && x.team_slug === slug && x.login === login), g.state()));
+        }),
+        'teams/remove-membership-for-user-in-org': teamsRemoveMembershipForUserInOrg,
+        'teams/list-repos-in-org': teamsListReposInOrg,
+        // 204 when the team holds a grant on the repo, else 404
+        'teams/check-permissions-for-repo-in-org': teamsCheckPermissionsForRepoInOrg,
+        'teams/add-or-update-repo-permissions-in-org': underTeam(async (ctx, g, org, slug) => {
+            const repo = `${decodeURIComponent(g.seg[5])}/${decodeURIComponent(g.seg[6])}`;
+            await put(ctx, { operation: 'team_repo.grant', subjectType: 'team_repo', subjectId: `teamrepo:${org}#${slug}#${repo}`, fields: { org, team_slug: slug, repository: repo, permission: g.body.permission ?? 'pull' } });
+            return send(ctx, { status: 204, body: undefined });
+        }),
+        'teams/remove-repo-in-org': teamsRemoveRepoInOrg,
+    };
+}

package/dist/src/semantics/packages.d.ts

@@ -0,0 +1,2 @@
+import type { Semantics } from '@volter/world-core';
+export declare function packagesSemantics(): Record<string, Semantics>;

package/dist/src/semantics/packages.js

@@ -0,0 +1,55 @@
+import { githubNotFound, paginate, toGithubPackage, toGithubPackageVersion } from "../github-twin.js";
+import { gh, put, send } from "./shared.js";
+const versionCount = (st, p) => st.packageVersions.filter((v) => v.owner === p.owner && v.package_type === p.package_type && v.package_name === p.name).length;
+/** A read or write under /user/packages/:type/:name: Not Found when the package does not exist. */
+const underPackage = (serve) => async (ctx) => {
+    const { seg, state } = gh(ctx);
+    const type = decodeURIComponent(seg[2]);
+    const name = decodeURIComponent(seg[3]);
+    const st = state();
+    const pkg = st.packages.find((p) => p.owner === 'octocat' && p.package_type === type && p.name === name);
+    return pkg ? serve(ctx, st, pkg, type, name) : send(ctx, githubNotFound());
+};
+export function packagesSemantics() {
+    const packagesListPackagesForAuthenticatedUser = async (ctx) => {
+        const { query, state } = gh(ctx);
+        const st = state();
+        const pkgType = new URLSearchParams((query ?? '').replace(/^\?/, '')).get('package_type');
+        let items = st.packages.filter((p) => p.owner === 'octocat');
+        if (pkgType)
+            items = items.filter((p) => p.package_type === pkgType);
+        return ctx.reply(paginate(items, query).map((p) => toGithubPackage(p, versionCount(st, p))));
+    };
+    const packagesDeletePackageForAuthenticatedUser = (ctx) => (underPackage(async (ctx, _st, pkg, type, name) => {
+        await put(ctx, { operation: 'package.delete', subjectType: 'package', subjectId: `package:${pkg.id}`, fields: { deleted: true, name } });
+        for (const v of gh(ctx).state().packageVersions.filter((x) => x.owner === 'octocat' && x.package_type === type && x.package_name === name)) {
+            await put(ctx, { operation: 'package_version.delete', subjectType: 'package_version', subjectId: `packageversion:${v.id}`, fields: { deleted: true, package_name: name } });
+        }
+        return send(ctx, { status: 204, body: undefined });
+    }))(ctx);
+    const packagesDeletePackageVersionForAuthenticatedUser = async (ctx) => {
+        const { seg, state } = gh(ctx);
+        const type = decodeURIComponent(seg[2]);
+        const name = decodeURIComponent(seg[3]);
+        const vid = Number(decodeURIComponent(seg[5]));
+        if (!state().packageVersions.find((x) => x.owner === 'octocat' && x.package_type === type && x.package_name === name && x.id === vid))
+            return send(ctx, githubNotFound());
+        await put(ctx, { operation: 'package_version.delete', subjectType: 'package_version', subjectId: `packageversion:${vid}`, fields: { deleted: true, package_name: name } });
+        return send(ctx, { status: 204, body: undefined });
+    };
+    const packagesGetAllPackageVersionsForPackageOwnedByAuthenticatedUser = (ctx) => (underPackage(async (ctx, st, _pkg, type, name) => ctx.reply(paginate(st.packageVersions.filter((v) => v.owner === 'octocat' && v.package_type === type && v.package_name === name).sort((a, b) => String(b.created_at ?? '').localeCompare(String(a.created_at ?? '')) || b.id - a.id), gh(ctx).query).map(toGithubPackageVersion))))(ctx);
+    const packagesGetPackageVersionForAuthenticatedUser = (ctx) => (underPackage(async (ctx, st, _pkg, type, name) => {
+        const vid = Number(decodeURIComponent(gh(ctx).seg[5]));
+        const v = st.packageVersions.find((x) => x.owner === 'octocat' && x.package_type === type && x.package_name === name && x.id === vid);
+        return send(ctx, v ? { status: 200, body: toGithubPackageVersion(v) } : githubNotFound());
+    }))(ctx);
+    return {
+        'packages/list-packages-for-authenticated-user': packagesListPackagesForAuthenticatedUser,
+        'packages/get-package-for-authenticated-user': underPackage(async (ctx, st, pkg) => ctx.reply(toGithubPackage(pkg, versionCount(st, pkg)))),
+        'packages/get-all-package-versions-for-package-owned-by-authenticated-user': packagesGetAllPackageVersionsForPackageOwnedByAuthenticatedUser,
+        'packages/get-package-version-for-authenticated-user': packagesGetPackageVersionForAuthenticatedUser,
+        // deleting a package deletes its versions
+        'packages/delete-package-for-authenticated-user': packagesDeletePackageForAuthenticatedUser,
+        'packages/delete-package-version-for-authenticated-user': packagesDeletePackageVersionForAuthenticatedUser,
+    };
+}

package/dist/src/semantics/pages.d.ts

@@ -0,0 +1,2 @@
+import type { Semantics } from '@volter/world-core';
+export declare function pagesSemantics(): Record<string, Semantics>;