refactor: redo the redirection

src/lib/components/embeds/external-embed.svelte

···
 
 	const external = $derived(embed.external);
 
-	const domain = $derived(safeUrlParse(external.uri)?.host.replace(/^www\./, ''));
-	const redirectUrl = $derived(redirectBskyUrl(external.uri));
+	const parsed = $derived(safeUrlParse(external.uri));
+
+	const domain = $derived(parsed?.host.replace(/^www\./, ''));
+	const redir = $derived(parsed && redirectBskyUrl(parsed));
 </script>
 
 <a
-	target={!redirectUrl ? '_blank' : undefined}
-	href={redirectUrl || (domain ? external.uri : '')}
+	target={!redir || redir.type === 'external' ? '_blank' : undefined}
+	href={redir ? redir.url : domain ? external.uri : ''}
 	rel="noopener noreferrer nofollow"
 	class="external-embed"
 >

src/lib/components/richtext-raw-renderer.svelte

···
 </script>
 
 <script lang="ts">
+	import { tokenize } from '@atcute/bluesky-richtext-parser';
+
 	import { base } from '$app/paths';
-	import { redirectBskyUrl } from '$lib/redirector';
 
-	import { tokenize } from '@atcute/bluesky-richtext-parser';
+	import { redirectBskyUrl } from '$lib/redirector';
+	import { safeUrlParse } from '$lib/utils/url';
 
 	interface Props {
 		text: string;
···
 <p class={`rich-text` + (large ? ` is-large` : ` is-small`)}>
 	{#each tokenize(text) as token}
 		{#if token.type === 'autolink'}
-			{@const redirectUrl = redirectBskyUrl(token.url)}
-			{@const label = token.raw.replace(HTTP_RE, '')}
+			{@const parsed = safeUrlParse(token.url)}
 
-			{#if redirectUrl}
-				<a href={redirectUrl} class="link">{label}</a>
+			{#if parsed === null}
+				{token.raw}
 			{:else}
-				<a target="_blank" href={token.url} rel="noopener nofollow" class="link">
-					{label}
-				</a>
+				{@const redir = redirectBskyUrl(parsed)}
+				{@const label = token.raw.replace(HTTP_RE, '')}
+
+				{#if redir && redir.type === 'internal'}
+					<a href={redir.url} class="link">{label}</a>
+				{:else}
+					<a target="_blank" href={redir ? redir.url : parsed.href} rel="noopener nofollow" class="link"
+						>{label}</a
+					>
+				{/if}
 			{/if}
 		{:else if token.type === 'mention'}
 			<a href="{base}/{token.handle.toLowerCase()}" class="mention">{token.raw}</a>

src/lib/components/richtext-renderer.svelte

···
 	import { base } from '$app/paths';
 
 	import { redirectBskyUrl } from '$lib/redirector';
+	import { safeUrlParse } from '$lib/utils/url';
 
 	interface Props {
 		text: string;
···
 		{#if !feature}
 			{segment.text}
 		{:else if feature.$type === 'app.bsky.richtext.facet#link'}
-			{@const redirectUrl = redirectBskyUrl(feature.uri)}
+			{@const parsed = safeUrlParse(feature.uri)}
 
-			{#if redirectUrl}
-				<a href={redirectUrl} class="link">{segment.text}</a>
+			{#if parsed === null}
+				{segment.text}
 			{:else}
-				<a target="_blank" href={feature.uri} rel="noopener nofollow" class="link">{segment.text}</a>
+				{@const redir = redirectBskyUrl(parsed)}
+
+				{#if redir && redir.type === 'internal'}
+					<a href={redir.url} class="link">{segment.text}</a>
+				{:else}
+					<a target="_blank" href={redir ? redir.url : parsed.href} rel="noopener nofollow" class="link"
+						>{segment.text}</a
+					>
+				{/if}
 			{/if}
 		{:else if feature.$type === 'app.bsky.richtext.facet#mention'}
 			<a href="{base}/{feature.did}" class="mention">{segment.text}</a>

src/lib/redirector.ts

···
 import { base } from '$app/paths';
-import { parsePartialAtUri, type PartialAtUri } from './types/at-uri';
+import { type PartialAtUri, parsePartialAtUri } from './types/at-uri';
 
 import { isDid, isHandle } from './types/identity';
 import { isRecordKey, isTid } from './types/rkey';
···
 } from './utils/bluesky/urls';
 import { safeUrlParse } from './utils/url';
 
-export const redirectBskyUrl = (rawUrl: string): string | null | undefined => {
-	const url = safeUrlParse(rawUrl);
-	if (!url) {
-		return;
-	}
+export type RedirectResult =
+	// Internal link pointing to ourselves
+	| { type: 'internal'; url: string }
+	// External link pointing to another website
+	| { type: 'external'; url: string }
+	// Matched but not considered valid
+	| null
+	// Not matched
+	| undefined;
 
+export const redirectBskyUrl = (url: URL): RedirectResult => {
 	const host = url.host;
 	const pathname = url.pathname;
 	let match: RegExpExecArray | null | undefined;
···
 				return null;
 			}
 
-			return `${base}/${match[1]}`;
+			return { type: 'internal', url: `${base}/${match[1]}` };
 		}
 
 		if ((match = BSKY_POST_LINK_RE.exec(pathname))) {
···
 				return null;
 			}
 
-			return `${base}/${actor}/${rkey}#main`;
+			return { type: 'internal', url: `${base}/${actor}/${rkey}#main` };
 		}
 
 		if ((match = BSKY_FEED_LINK_RE.exec(pathname))) {
···
 				return null;
 			}
 
-			return `${base}/${actor}/feeds/${rkey}`;
+			return { type: 'internal', url: `${base}/${actor}/feeds/${rkey}` };
 		}
 
 		if ((match = BSKY_LIST_LINK_RE.exec(pathname))) {
···
 				return null;
 			}
 
-			return `${base}/${actor}/lists/${rkey}`;
+			return { type: 'internal', url: `${base}/${actor}/lists/${rkey}` };
 		}
 
 		if ((match = BSKY_STARTERPACK_LINK_RE.exec(pathname))) {
···
 				return null;
 			}
 
-			return `${base}/${actor}/packs/${rkey}`;
+			return { type: 'internal', url: `${base}/${actor}/packs/${rkey}` };
 		}
 
 		if ((match = BSKY_SEARCH_LINK_RE.exec(pathname))) {
···
 				return null;
 			}
 
-			return `${base}/search/posts?q=${encodeURIComponent(query)}`;
+			return { type: 'internal', url: `${base}/search/posts?q=${encodeURIComponent(query)}` };
 		}
 
 		if ((match = BSKY_HASHTAG_LINK_RE.exec(pathname))) {
 			const [, tag] = match;
 
-			return `${base}/search/posts?q=${encodeURIComponent('#' + tag)}`;
+			return { type: 'internal', url: `${base}/search/posts?q=${encodeURIComponent('#' + tag)}` };
 		}
 
 		return null;
 	}
 
 	if (host === 'go.bsky.app') {
+		if (pathname === '/redirect') {
+			const raw = url.searchParams.get('u');
+			if (raw === null) {
+				return null;
+			}
+
+			const parsed = safeUrlParse(raw);
+			if (parsed === null) {
+				return null;
+			}
+
+			return redirectBskyUrl(parsed) || { type: 'external', url: parsed.href };
+		}
+
 		if ((match = BSKY_GO_SHORTLINK_RE.exec(pathname))) {
 			const [, id] = match;
 
-			return `${base}/go/${id}`;
+			return { type: 'internal', url: `${base}/go/${id}` };
 		}
 	}
 
···
 // https://skywriter.blue/pages/georgemonbiot.bsky.social/post/3livzzfqc4c2c
 const SKYWRITER_UNROLL_RE = /^\/pages\/([^/]+)\/post\/([^/]+)\/?$/;
 
-export const redirectOtherUrl = (rawUrl: string): string | null | undefined => {
-	const url = safeUrlParse(rawUrl);
-	if (!url) {
-		return;
-	}
-
+export const redirectOtherUrl = (url: URL): RedirectResult => {
 	const host = url.host;
 	const pathname = url.pathname;
 	let match: RegExpExecArray | null | undefined;
···
 			return null;
 		}
 
-		return `${base}/${author}/${post}#main`;
+		return { type: 'internal', url: `${base}/${author}/${post}#main` };
 	}
 
 	if (host === 'skywriter.blue') {
···
 				return null;
 			}
 
-			return `${base}/${actor}/${rkey}/unroll`;
+			return { type: 'internal', url: `${base}/${actor}/${rkey}/unroll` };
 		}
 	}
 
 	// https://skyview.social/?url=https://bsky.app/profile/did:plc:tyt7lpgpfbn3c37tylht7ksy/post/3lithx22epk2l&viewtype=unroll
 	if (host === 'skyview.social') {
 		const uri = url.searchParams.get('url');
-
 		if (uri === null) {
 			return null;
 		}
 
-		const redirect = redirectBskyUrl(uri);
+		const parsed = safeUrlParse(uri);
+		if (parsed === null) {
+			return null;
+		}
+
+		const redirect = redirectBskyUrl(parsed);
 		if (redirect == null) {
 			return null;
 		}
···
 	return;
 };
 
-export const redirectAtUri = (raw: string): string | null | undefined => {
+export const redirectAtUri = (raw: string): RedirectResult => {
 	let uri: PartialAtUri;
 	try {
 		uri = parsePartialAtUri(raw);
···
 	if (uri.rkey) {
 		switch (uri.collection) {
 			case 'app.bsky.actor.profile': {
-				return `${base}/${uri.repo}`;
+				return { type: 'internal', url: `${base}/${uri.repo}` };
 			}
 			case 'app.bsky.feed.post': {
 				if (!isTid(uri.rkey)) {
 					return null;
 				}
 
-				return `${base}/${uri.repo}/${uri.rkey}#main`;
+				return { type: 'internal', url: `${base}/${uri.repo}/${uri.rkey}#main` };
 			}
 			case 'app.bsky.feed.generator': {
-				return `${base}/${uri.repo}/feeds/${uri.rkey}`;
+				return { type: 'internal', url: `${base}/${uri.repo}/feeds/${uri.rkey}` };
 			}
 			case 'app.bsky.graph.list': {
-				return `${base}/${uri.repo}/lists/${uri.rkey}`;
+				return { type: 'internal', url: `${base}/${uri.repo}/lists/${uri.rkey}` };
 			}
 			case 'app.bsky.graph.starterpack': {
-				return `${base}/${uri.repo}/packs/${uri.rkey}`;
+				return { type: 'internal', url: `${base}/${uri.repo}/packs/${uri.rkey}` };
 			}
 		}
 	}
 
 	if (uri.collection === undefined) {
-		return `${base}/${uri.repo}`;
+		return { type: 'internal', url: `${base}/${uri.repo}` };
 	}
 
 	return null;

src/routes/(app)/+page.server.ts

···
 
 import { base } from '$app/paths';
 
-import { redirectAtUri, redirectBskyUrl, redirectOtherUrl } from '$lib/redirector';
+import { redirectAtUri, redirectBskyUrl, redirectOtherUrl, type RedirectResult } from '$lib/redirector';
+import { safeUrlParse } from '$lib/utils/url';
 
 const MAYBE_HANDLE_RE = /^@[a-zA-Z0-9-. ]+$/;
 
···
 
 		query = query.trim();
 
-		const redirectUrl = redirectBskyUrl(query) || redirectOtherUrl(query) || redirectAtUri(query);
-		if (redirectUrl) {
-			redirect(302, redirectUrl);
+		let redir: RedirectResult | undefined;
+		if (query.startsWith('at://')) {
+			redir = redirectAtUri(query);
+		} else {
+			const url = safeUrlParse(query);
+			if (url) {
+				redir = redirectBskyUrl(url) || redirectOtherUrl(url);
+			}
+		}
+
+		if (redir && redir.type === 'internal') {
+			redirect(302, redir.url);
 		}
 
 		return fail(400, { place: 'redirect', error: `Invalid link provided` });

src/routes/go/[shortid]/+page.ts

···
 import type { PageLoad } from './$types';
 
 import { redirectBskyUrl } from '$lib/redirector';
+import { safeUrlParse } from '$lib/utils/url';
 
 const jsonSchema = v.object({
 	url: v.string(),
···
 	}
 
 	const raw = await response.json();
-	const result = jsonSchema.try(raw);
 
+	const result = jsonSchema.try(raw);
 	if (!result.ok) {
 		error(500, `Invalid response from upstream server`);
 	}
 
-	const url = result.value.url;
-	const redirectUrl = redirectBskyUrl(url);
+	const url = safeUrlParse(result.value.url);
+	if (!url) {
+		error(500, `Invalid URL from upstream server; got ${result.value.url}`);
+	}
 
-	if (!redirectUrl) {
+	const redir = redirectBskyUrl(url);
+
+	if (!redir || redir.type !== 'internal') {
 		error(500, `Invalid URL from upstream server; got ${url}`);
 	}
 
-	redirect(301, redirectUrl);
+	redirect(301, redir.url);
 };