Add socialweb account migration settings UI

apps/activitypub/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryghost/activitypub",
-  "version": "3.1.23",
+  "version": "3.1.25",
   "license": "MIT",
   "repository": {
     "type": "git",

apps/activitypub/src/api/activitypub.test.ts

@@ -1597,6 +1597,190 @@ describe('ActivityPubAPI', function () {
         });
     });
 
+    describe('accountAliases', function () {
+        test('It fetches account aliases', async function () {
+            const fakeFetch = Fetch({
+                'https://auth.api/': {
+                    response: JSONResponse({
+                        identities: [{
+                            token: 'fake-token'
+                        }]
+                    })
+                },
+                [`https://activitypub.api/.ghost/activitypub/v1/aliases`]: {
+                    response: JSONResponse({
+                        destination: {
+                            handle: '@index@example.com',
+                            apId: 'https://example.com/.ghost/activitypub/users/index'
+                        },
+                        aliases: [{
+                            apId: 'https://mastodon.social/users/old'
+                        }]
+                    })
+                }
+            });
+
+            const api = new ActivityPubAPI(
+                new URL('https://activitypub.api'),
+                new URL('https://auth.api'),
+                'index',
+                fakeFetch
+            );
+
+            const result = await api.getAccountAliases();
+
+            expect(result).toEqual({
+                destination: {
+                    handle: '@index@example.com',
+                    apId: 'https://example.com/.ghost/activitypub/users/index'
+                },
+                aliases: [{
+                    apId: 'https://mastodon.social/users/old'
+                }]
+            });
+        });
+
+        test('It adds an account alias', async function () {
+            const fakeFetch = Fetch({
+                'https://auth.api/': {
+                    response: JSONResponse({
+                        identities: [{
+                            token: 'fake-token'
+                        }]
+                    })
+                },
+                [`https://activitypub.api/.ghost/activitypub/v1/aliases`]: {
+                    async assert(_resource, init) {
+                        expect(init?.method).toEqual('POST');
+                        expect(init?.body).toEqual('{"sourceHandle":"@old@mastodon.social"}');
+                    },
+                    response: JSONResponse({
+                        destination: {
+                            handle: '@index@example.com',
+                            apId: 'https://example.com/.ghost/activitypub/users/index'
+                        },
+                        aliases: [{
+                            apId: 'https://mastodon.social/users/old'
+                        }]
+                    })
+                }
+            });
+
+            const api = new ActivityPubAPI(
+                new URL('https://activitypub.api'),
+                new URL('https://auth.api'),
+                'index',
+                fakeFetch
+            );
+
+            const result = await api.addAccountAlias('@old@mastodon.social');
+
+            expect(result.aliases).toEqual([{
+                apId: 'https://mastodon.social/users/old'
+            }]);
+        });
+
+        test('It returns an empty alias response when adding an account alias has no response body', async function () {
+            const fakeFetch = Fetch({
+                'https://auth.api/': {
+                    response: JSONResponse({
+                        identities: [{
+                            token: 'fake-token'
+                        }]
+                    })
+                },
+                [`https://activitypub.api/.ghost/activitypub/v1/aliases`]: {
+                    response: new Response(null, {status: 204})
+                }
+            });
+
+            const api = new ActivityPubAPI(
+                new URL('https://activitypub.api'),
+                new URL('https://auth.api'),
+                'index',
+                fakeFetch
+            );
+
+            const result = await api.addAccountAlias('@old@mastodon.social');
+
+            expect(result).toEqual({
+                destination: {
+                    handle: '',
+                    apId: ''
+                },
+                aliases: []
+            });
+        });
+
+        test('It removes an account alias', async function () {
+            const fakeFetch = Fetch({
+                'https://auth.api/': {
+                    response: JSONResponse({
+                        identities: [{
+                            token: 'fake-token'
+                        }]
+                    })
+                },
+                [`https://activitypub.api/.ghost/activitypub/v1/aliases`]: {
+                    async assert(_resource, init) {
+                        expect(init?.method).toEqual('DELETE');
+                        expect(init?.body).toEqual('{"actorUri":"https://mastodon.social/users/old"}');
+                    },
+                    response: JSONResponse({
+                        destination: {
+                            handle: '@index@example.com',
+                            apId: 'https://example.com/.ghost/activitypub/users/index'
+                        },
+                        aliases: []
+                    })
+                }
+            });
+
+            const api = new ActivityPubAPI(
+                new URL('https://activitypub.api'),
+                new URL('https://auth.api'),
+                'index',
+                fakeFetch
+            );
+
+            const result = await api.removeAccountAlias('https://mastodon.social/users/old');
+
+            expect(result.aliases).toEqual([]);
+        });
+
+        test('It returns an empty alias response when removing an account alias has no response body', async function () {
+            const fakeFetch = Fetch({
+                'https://auth.api/': {
+                    response: JSONResponse({
+                        identities: [{
+                            token: 'fake-token'
+                        }]
+                    })
+                },
+                [`https://activitypub.api/.ghost/activitypub/v1/aliases`]: {
+                    response: new Response(null, {status: 204})
+                }
+            });
+
+            const api = new ActivityPubAPI(
+                new URL('https://activitypub.api'),
+                new URL('https://auth.api'),
+                'index',
+                fakeFetch
+            );
+
+            const result = await api.removeAccountAlias('https://mastodon.social/users/old');
+
+            expect(result).toEqual({
+                destination: {
+                    handle: '',
+                    apId: ''
+                },
+                aliases: []
+            });
+        });
+    });
+
     describe('enableBluesky', function () {
         test('It enables bluesky', async function () {
             const fakeFetch = Fetch({

apps/activitypub/src/api/activitypub.ts

@@ -102,6 +102,39 @@ export type AccountFollowsType = 'following' | 'followers';
 
 type GetAccountResponse = Account
 
+export interface AccountAlias {
+    apId: string;
+}
+
+export interface AccountAliasesResponse {
+    destination: {
+        handle: string;
+        apId: string;
+    };
+    aliases: AccountAlias[];
+}
+
+function emptyAccountAliasesResponse(): AccountAliasesResponse {
+    return {
+        destination: {
+            handle: '',
+            apId: ''
+        },
+        aliases: []
+    };
+}
+
+function parseAccountAliasesResponse(json: object | null): AccountAliasesResponse {
+    if (json === null || !('destination' in json)) {
+        return emptyAccountAliasesResponse();
+    }
+
+    return {
+        destination: json.destination as AccountAliasesResponse['destination'],
+        aliases: 'aliases' in json && Array.isArray(json.aliases) ? json.aliases as AccountAlias[] : []
+    };
+}
+
 export type FollowAccount = Pick<Account, 'id' | 'name' | 'handle' | 'avatarUrl' | 'blockedByMe' | 'domainBlockedByMe'> & {isFollowing: true};
 
 export interface GetAccountFollowsResponse {
@@ -484,6 +517,27 @@ export class ActivityPubAPI {
         };
     }
 
+    async getAccountAliases(): Promise<AccountAliasesResponse> {
+        const url = new URL('.ghost/activitypub/v1/aliases', this.apiUrl);
+        const json = await this.fetchJSON(url);
+
+        return parseAccountAliasesResponse(json);
+    }
+
+    async addAccountAlias(sourceHandle: string): Promise<AccountAliasesResponse> {
+        const url = new URL('.ghost/activitypub/v1/aliases', this.apiUrl);
+        const json = await this.fetchJSON(url, 'POST', {sourceHandle});
+
+        return parseAccountAliasesResponse(json);
+    }
+
+    async removeAccountAlias(actorUri: string): Promise<AccountAliasesResponse> {
+        const url = new URL('.ghost/activitypub/v1/aliases', this.apiUrl);
+        const json = await this.fetchJSON(url, 'DELETE', {actorUri});
+
+        return parseAccountAliasesResponse(json);
+    }
+
     async getFeed(next?: string): Promise<PaginatedPostsResponse> {
         return this.getPaginatedPosts('.ghost/activitypub/v1/feed/notes', next);
     }

apps/activitypub/src/hooks/use-activity-pub-queries.ts

@@ -1,5 +1,6 @@
 import {
     type Account,
+    type AccountAliasesResponse,
     type AccountFollowsType,
     type AccountSearchResult,
     ActivityPubAPI,
@@ -74,6 +75,7 @@ const QUERY_KEYS = {
         return ['profile_posts', profileHandle];
     },
     account: (handle: string) => ['account', handle],
+    accountAliases: (handle: string) => ['account_aliases', handle],
     accountFollows: (handle: string, type: AccountFollowsType) => ['account_follows', handle, type],
     searchResults: (query: string) => ['search_results', query],
     suggestedProfiles: (handle: string, limit: number) => ['suggested_profiles', handle, limit],
@@ -1654,6 +1656,50 @@ export function useAccountFollowsForUser(profileHandle: string, type: AccountFol
     });
 }
 
+export function useAccountAliasesForUser(handle: string) {
+    return useQuery({
+        queryKey: QUERY_KEYS.accountAliases(handle),
+        async queryFn() {
+            const siteUrl = await getSiteUrl();
+            const api = createActivityPubAPI(handle, siteUrl);
+
+            return api.getAccountAliases();
+        }
+    });
+}
+
+export function useAddAccountAliasMutationForUser(handle: string) {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        async mutationFn(sourceHandle: string) {
+            const siteUrl = await getSiteUrl();
+            const api = createActivityPubAPI(handle, siteUrl);
+
+            return api.addAccountAlias(sourceHandle);
+        },
+        onSuccess(response: AccountAliasesResponse) {
+            queryClient.setQueryData(QUERY_KEYS.accountAliases(handle), response);
+        }
+    });
+}
+
+export function useRemoveAccountAliasMutationForUser(handle: string) {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        async mutationFn(actorUri: string) {
+            const siteUrl = await getSiteUrl();
+            const api = createActivityPubAPI(handle, siteUrl);
+
+            return api.removeAccountAlias(actorUri);
+        },
+        onSuccess(response: AccountAliasesResponse) {
+            queryClient.setQueryData(QUERY_KEYS.accountAliases(handle), response);
+        }
+    });
+}
+
 export function useFeedForUser(options: {enabled: boolean}) {
     const queryKey = QUERY_KEYS.feed;
     const queryClient = useQueryClient();

apps/activitypub/src/routes.tsx

@@ -3,6 +3,7 @@ import AppError from '@components/layout/error';
 import {Navigate, Outlet, RouteObject, lazyComponent} from '@tryghost/admin-x-framework';
 
 const basePath = import.meta.env.VITE_TEST ? '' : 'activitypub';
+const accountMigrationPath = 'preferences/move';
 
 export type CustomRouteObject = RouteObject & {
     pageTitle?: string;
@@ -106,6 +107,12 @@ export const routes: CustomRouteObject[] = [
                 lazy: lazyComponent(() => import('./views/preferences/components/bluesky-sharing')),
                 showBackButton: true
             },
+            {
+                path: accountMigrationPath,
+                lazy: lazyComponent(() => import('./views/preferences/components/account-migration')),
+                pageTitle: 'Account migration',
+                showBackButton: true
+            },
             {
                 path: 'welcome',
                 lazy: lazyComponent(() => import('./components/layout/onboarding')),