@absolutejs/auth 0.4.0 → 0.5.0

package/src/index.ts

@@ -1,88 +0,0 @@
-import { OAuth2RequestError, ArcticFetchError } from 'arctic';
-import { Elysia } from 'elysia';
-import { authorize } from './authorize';
-import { callback } from './callback';
-import { logout } from './logout';
-import { protectRoute } from './protectRoute';
-import { normalizedProviderKeys, providers } from './providers';
-import { refresh } from './refresh';
-import { revoke } from './revoke';
-import { status } from './status';
-import { isValidProviderKey } from './typeGuards';
-import { AbsoluteAuthProps, ClientProviders } from './types';
-
-export const absoluteAuth = <UserType>({
-	config,
-	authorizeRoute,
-	callbackRoute,
-	logoutRoute,
-	statusRoute,
-	refreshRoute,
-	revokeRoute,
-	onAuthorize,
-	onCallback,
-	onStatus,
-	onRefresh,
-	onLogout,
-	onRevoke
-}: AbsoluteAuthProps<UserType>) => {
-	const clientProviders = Object.keys(config).reduce<ClientProviders>(
-		(acc, key) => {
-			if (!Object.prototype.hasOwnProperty.call(config, key)) return acc;
-
-			if (!isValidProviderKey(key)) {
-				console.error(`Provider ${key} is not supported`);
-
-				return acc;
-			}
-
-			const options = config[key];
-			if (!options) return acc;
-
-			const normalizedProvider = key.toLowerCase();
-			const originalProviderKey =
-				normalizedProviderKeys[normalizedProvider];
-
-			if (!isValidProviderKey(originalProviderKey)) {
-				console.error(`Provider ${key} is not supported`);
-
-				return acc;
-			}
-
-			const Provider = providers[originalProviderKey];
-			const { credentials, scopes = [], searchParams = [] } = options;
-
-			// @ts-expect-error: dynamic constructor parameters
-			const providerInstance = new Provider(...credentials);
-
-			acc[normalizedProvider] = {
-				providerInstance,
-				scopes,
-				searchParams
-			};
-
-			return acc;
-		},
-		{}
-	);
-
-	return new Elysia()
-		.error('OAUTH2_REQUEST_ERROR', OAuth2RequestError)
-		.error('ARCTIC_FETCH_ERROR', ArcticFetchError)
-		.use(logout({ logoutRoute, onLogout }))
-		.use(revoke({ clientProviders, onRevoke, revokeRoute }))
-		.use(status<UserType>({ clientProviders, onStatus, statusRoute }))
-		.use(refresh({ clientProviders, onRefresh, refreshRoute }))
-		.use(authorize({ authorizeRoute, clientProviders, onAuthorize }))
-		.use(
-			callback<UserType>({
-				callbackRoute,
-				clientProviders,
-				onCallback
-			})
-		)
-		.use(protectRoute())
-		.as('plugin');
-};
-
-export * from './utils';

package/src/logout.ts

@@ -1,39 +0,0 @@
-import { Elysia } from 'elysia';
-
-type LogoutProps = {
-	logoutRoute?: string;
-	onLogout?: () => void;
-};
-
-export const logout = ({ logoutRoute = 'logout', onLogout }: LogoutProps) =>
-	new Elysia().post(
-		`/${logoutRoute}`,
-		async ({ error, cookie: { user_session_id, auth_provider } }) => {
-			if (auth_provider.value === undefined) {
-				return error('Unauthorized', 'No auth provider found');
-			}
-
-			try {
-				onLogout?.();
-
-				user_session_id.remove();
-				auth_provider.remove();
-
-				return new Response('Succesfuly Logged Out', {
-					status: 204
-				});
-			} catch (err) {
-				if (err instanceof Error) {
-					return error(
-						'Internal Server Error',
-						`Failed to logout: ${err.message}`
-					);
-				}
-
-				return error(
-					'Internal Server Error',
-					`Failed to logout: Unknown error: ${err}`
-				);
-			}
-		}
-	);

package/src/profiles.ts

@@ -1,322 +0,0 @@
-export type ProfileRequest = {
-	endpoint: string;
-	method?: 'GET' | 'POST';
-	authIn: 'header' | 'query';
-	tokenParam?: string;
-	headers?: Record<string, string>;
-	body?: any;
-};
-
-export async function fetchUserProfile(provider: string, accessToken: string) {
-	const cfg: ProfileRequest | undefined = profileConfigs[provider];
-	if (!cfg) {
-		throw new Error(`Unknown provider: ${provider}`);
-	}
-
-	let url = cfg.endpoint;
-	const method = cfg.method ?? 'GET';
-	const headers: Record<string, string> = {};
-
-	// Merge any static headers first
-	if (cfg.headers) {
-		Object.assign(headers, cfg.headers);
-	}
-
-	// Place token in header or query
-	if (cfg.authIn === 'header') {
-		headers['Authorization'] = `Bearer ${accessToken}`;
-	} else {
-		const tokenKey = cfg.tokenParam ?? 'access_token';
-		const sep = url.includes('?') ? '&' : '?';
-		url = `${url}${sep}${tokenKey}=${encodeURIComponent(accessToken)}`;
-	}
-
-	const init: RequestInit = { method, headers };
-
-	if (method === 'POST' && cfg.body) {
-		headers['Content-Type'] = 'application/json';
-		init.body = JSON.stringify(cfg.body);
-	}
-
-	const res = await fetch(url, init);
-	if (!res.ok) {
-		const errText = await res.text();
-		throw new Error(
-			`Failed to fetch ${provider} profile: ${res.status} ${errText}`
-		);
-	}
-
-	return res.json();
-}
-
-export const profileConfigs: Record<string, ProfileRequest> = {
-	facebook: {
-		endpoint: 'https://graph.facebook.com/me?fields=id,name,picture,email',
-		method: 'GET',
-		authIn: 'query',
-		tokenParam: 'access_token'
-	},
-	anilist: {
-		endpoint: 'https://graphql.anilist.co',
-		method: 'POST',
-		authIn: 'header',
-		headers: {
-			'Content-Type': 'application/json',
-			Accept: 'application/json'
-		},
-		body: {
-			query: `query { Viewer { id name } }`
-		}
-	},
-	atlassian: {
-		endpoint: 'https://api.atlassian.com/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	battlenet: {
-		endpoint: 'https://oauth.battle.net/userinfo',
-		method: 'GET',
-		authIn: 'header'
-	},
-	bitbucket: {
-		endpoint: 'https://api.bitbucket.org/2.0/user',
-		method: 'GET',
-		authIn: 'header'
-	},
-	box: {
-		endpoint: 'https://api.box.com/2.0/users/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	bungie: {
-		endpoint:
-			'https://www.bungie.net/Platform/User/GetCurrentBungieNetUser',
-		method: 'GET',
-		authIn: 'header',
-		headers: {
-			'X-API-Key': '<YOUR_API_KEY>'
-		}
-	},
-	coinbase: {
-		endpoint: 'https://api.coinbase.com/v2/user',
-		method: 'GET',
-		authIn: 'header'
-	},
-	discord: {
-		endpoint: 'https://discord.com/api/users/@me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	donationAlerts: {
-		endpoint: 'https://www.donationalerts.com/api/v1/user',
-		method: 'GET',
-		authIn: 'header'
-	},
-	dribbble: {
-		endpoint: 'https://api.dribbble.com/v2/user',
-		method: 'GET',
-		authIn: 'header'
-	},
-	dropbox: {
-		endpoint: 'https://api.dropboxapi.com/2/users/get_current_account',
-		method: 'GET',
-		authIn: 'header'
-	},
-	epicGames: {
-		endpoint: 'https://api.epicgames.dev/epic/oauth/v2/userInfo',
-		method: 'GET',
-		authIn: 'header'
-	},
-	etsy: {
-		endpoint: 'https://openapi.etsy.com/v3/application/users/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	figma: {
-		endpoint: 'https://api.figma.com/v1/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	gitea: {
-		endpoint: 'https://<YOUR_GITEA_DOMAIN>/api/v1/user',
-		method: 'GET',
-		authIn: 'header'
-	},
-	github: {
-		endpoint: 'https://api.github.com/user',
-		method: 'GET',
-		authIn: 'header'
-	},
-	gitlab: {
-		endpoint: 'https://gitlab.com/api/v4/user',
-		method: 'GET',
-		authIn: 'header'
-	},
-	intuit: {
-		endpoint: 'https://oauth.platform.intuit.com/oauth2/v1/userinfo',
-		method: 'GET',
-		authIn: 'header'
-	},
-	kakao: {
-		endpoint: 'https://kapi.kakao.com/v2/user/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	kick: {
-		endpoint: 'https://api.kick.com/v1/user',
-		method: 'GET',
-		authIn: 'header'
-	},
-	lichess: {
-		endpoint: 'https://lichess.org/api/account',
-		method: 'GET',
-		authIn: 'header'
-	},
-	line: {
-		endpoint: 'https://api.line.me/v2/profile',
-		method: 'GET',
-		authIn: 'header'
-	},
-	linear: {
-		endpoint: 'https://api.linear.app/graphql',
-		method: 'POST',
-		authIn: 'header',
-		headers: {
-			'Content-Type': 'application/json',
-			Accept: 'application/json'
-		},
-		body: {
-			query: `query { viewer { id name } }`
-		}
-	},
-	mastodon: {
-		endpoint: 'https://<YOUR_INSTANCE>/api/v1/accounts/verify_credentials',
-		method: 'GET',
-		authIn: 'header'
-	},
-	mercadoLibre: {
-		endpoint: 'https://api.mercadolibre.com/users/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	mercadoPago: {
-		endpoint: 'https://api.mercadopago.com/v1/users/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	myAnimeList: {
-		endpoint: 'https://api.myanimelist.net/v2/users/@me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	naver: {
-		endpoint: 'https://openapi.naver.com/v1/nid/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	notion: {
-		endpoint: 'https://api.notion.com/v1/users/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	osu: {
-		endpoint: 'https://osu.ppy.sh/api/v2/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	patreon: {
-		endpoint: 'https://www.patreon.com/api/oauth2/v2/identity',
-		method: 'GET',
-		authIn: 'header'
-	},
-	polar: {
-		endpoint: 'https://www.polaraccesslink.com/v3/users/<USER_ID>',
-		method: 'GET',
-		authIn: 'header'
-	},
-	reddit: {
-		endpoint: 'https://oauth.reddit.com/api/v1/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	roblox: {
-		endpoint: 'https://apis.roblox.com/oauth/v1/userinfo',
-		method: 'GET',
-		authIn: 'header'
-	},
-	shikimori: {
-		endpoint: 'https://shikimori.one/api/users/whoami',
-		method: 'GET',
-		authIn: 'header'
-	},
-	slack: {
-		endpoint: 'https://slack.com/api/users.identity',
-		method: 'GET',
-		authIn: 'query',
-		tokenParam: 'token'
-	},
-	spotify: {
-		endpoint: 'https://api.spotify.com/v1/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	startGg: {
-		endpoint: 'https://api.start.gg/gql/alpha',
-		method: 'POST',
-		authIn: 'header',
-		headers: {
-			'Content-Type': 'application/json',
-			Accept: 'application/json'
-		},
-		body: {
-			query: `query { currentUser { id slug email player { gamerTag } } }`
-		}
-	},
-	strava: {
-		endpoint: 'https://www.strava.com/api/v3/athlete',
-		method: 'GET',
-		authIn: 'header'
-	},
-	synology: {
-		endpoint: 'https://<YOUR_DOMAIN>/webman/sso/SSOUserInfo.cgi',
-		method: 'GET',
-		authIn: 'header'
-	},
-	tiktok: {
-		endpoint: 'https://open.douyin.com/oauth/userinfo',
-		method: 'GET',
-		authIn: 'query',
-		tokenParam: 'access_token'
-	},
-	tiltify: {
-		endpoint: 'https://tiltify.com/api/v3/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	tumblr: {
-		endpoint: 'https://api.tumblr.com/v2/user/info',
-		method: 'GET',
-		authIn: 'header'
-	},
-	twitch: {
-		endpoint: 'https://api.twitch.tv/helix/users',
-		method: 'GET',
-		authIn: 'header'
-	},
-	twitter: {
-		endpoint: 'https://api.twitter.com/2/users/me',
-		method: 'GET',
-		authIn: 'header'
-	},
-	vk: {
-		endpoint: 'https://api.vk.com/method/users.get',
-		method: 'GET',
-		authIn: 'query',
-		tokenParam: 'access_token'
-	},
-	zoom: {
-		endpoint: 'https://api.zoom.us/v2/users/me',
-		method: 'GET',
-		authIn: 'header'
-	}
-};

package/src/protectRoute.ts

@@ -1,33 +0,0 @@
-import { Elysia } from 'elysia';
-import { sessionStore } from './sessionStore';
-
-export const protectRoute = <UserType>() =>
-	new Elysia()
-		.use(sessionStore<UserType>())
-		.derive(
-			({ store: { session }, cookie: { user_session_id }, error }) => ({
-				protectRoute: async (
-					handleAuth: () => Promise<Response>,
-					handleAuthFail?: () => Promise<Response>
-				) => {
-					if (user_session_id.value === undefined) {
-						return (
-							handleAuthFail?.() ??
-							error('Unauthorized', 'No session ID found')
-						);
-					}
-
-					const userSession = session[user_session_id.value];
-
-					if (userSession === undefined) {
-						return (
-							handleAuthFail?.() ??
-							error('Unauthorized', 'No session found')
-						);
-					}
-
-					return handleAuth();
-				}
-			})
-		)
-		.as('plugin');

package/src/providers.ts

@@ -1,109 +0,0 @@
-import {
-	AmazonCognito,
-	AniList,
-	Apple,
-	Atlassian,
-	Auth0,
-	Authentik,
-	Bitbucket,
-	Box,
-	Coinbase,
-	Discord,
-	Dribbble,
-	Dropbox,
-	Facebook,
-	Figma,
-	Intuit,
-	GitHub,
-	GitLab,
-	Google,
-	Kakao,
-	KeyCloak,
-	Lichess,
-	Line,
-	Linear,
-	LinkedIn,
-	MicrosoftEntraId,
-	MyAnimeList,
-	Notion,
-	Okta,
-	Osu,
-	Patreon,
-	Reddit,
-	Roblox,
-	Salesforce,
-	Shikimori,
-	Slack,
-	Spotify,
-	Strava,
-	Tiltify,
-	Tumblr,
-	Twitch,
-	Twitter,
-	VK,
-	WorkOS,
-	Yahoo,
-	Yandex,
-	Zoom,
-	FortyTwo
-} from 'arctic';
-
-// TODO: When arctic adds better way to get the providers give a type to the object
-// eslint-disable-next-line custom/explicit-object-types
-export const providers = {
-	AmazonCognito,
-	AniList,
-	Apple,
-	Atlassian,
-	Auth0,
-	Authentik,
-	Bitbucket,
-	Box,
-	Coinbase,
-	Discord,
-	Dribbble,
-	Dropbox,
-	Facebook,
-	Figma,
-	FortyTwo,
-	GitHub,
-	GitLab,
-	Google,
-	Intuit,
-	Kakao,
-	KeyCloak,
-	Lichess,
-	Line,
-	Linear,
-	LinkedIn,
-	MicrosoftEntraId,
-	MyAnimeList,
-	Notion,
-	Okta,
-	Osu,
-	Patreon,
-	Reddit,
-	Roblox,
-	Salesforce,
-	Shikimori,
-	Slack,
-	Spotify,
-	Strava,
-	Tiltify,
-	Tumblr,
-	Twitch,
-	Twitter,
-	VK,
-	WorkOS,
-	Yahoo,
-	Yandex,
-	Zoom
-};
-
-export const normalizedProviderKeys = Object.keys(providers).reduce<
-	Record<string, string>
->((map, key) => {
-	map[key.toLowerCase()] = key;
-
-	return map;
-}, {});

package/src/refresh.ts

@@ -1,63 +0,0 @@
-import { Elysia } from 'elysia';
-import { isRefreshableProvider } from './typeGuards';
-import { ClientProviders } from './types';
-
-type RefreshProps = {
-	clientProviders: ClientProviders;
-	refreshRoute?: string;
-	onRefresh?: () => void;
-};
-
-export const refresh = ({
-	clientProviders,
-	refreshRoute = 'refresh',
-	onRefresh
-}: RefreshProps) =>
-	new Elysia().post(
-		`/${refreshRoute}`,
-		async ({ error, cookie: { user_refresh_token, auth_provider } }) => {
-			if (user_refresh_token.value === undefined) {
-				return error('Unauthorized', 'No refresh token found');
-			}
-
-			if (auth_provider.value === undefined) {
-				return error('Unauthorized', 'No auth provider found');
-			}
-
-			const normalizedProvider = auth_provider.value.toLowerCase();
-			const { providerInstance } = clientProviders[normalizedProvider];
-
-			if (!isRefreshableProvider(providerInstance)) {
-				return error('Not Implemented', 'Provider is not refreshable');
-			}
-
-			try {
-				//consider passing tokens to onRefresh
-				// const tokens = await providerInstance.refreshAccessToken(
-				// 	user_refresh_token.value
-				// );
-
-				await providerInstance.refreshAccessToken(
-					user_refresh_token.value
-				);
-
-				onRefresh?.();
-
-				return new Response('Token refreshed', {
-					status: 204
-				});
-			} catch (err) {
-				if (err instanceof Error) {
-					return error(
-						'Internal Server Error',
-						`Failed to refresh token: ${err.message}`
-					);
-				}
-
-				return error(
-					'Internal Server Error',
-					`Faile to refresh token: Unknown error: ${err}`
-				);
-			}
-		}
-	);

package/src/revoke.ts

@@ -1,61 +0,0 @@
-import { Elysia } from 'elysia';
-import { isRevocableProvider } from './typeGuards';
-import { ClientProviders } from './types';
-
-type RevokeProps = {
-	clientProviders: ClientProviders;
-	revokeRoute?: string;
-	onRevoke?: () => void;
-};
-
-export const revoke = ({
-	clientProviders,
-	revokeRoute = 'revoke',
-	onRevoke
-}: RevokeProps) =>
-	new Elysia().post(
-		`/${revokeRoute}/access-token`,
-		async ({ error, cookie: { user_refresh_token, auth_provider } }) => {
-			if (user_refresh_token.value === undefined) {
-				return error('Unauthorized', 'No refresh token found');
-			}
-
-			if (auth_provider.value === undefined) {
-				return error('Unauthorized', 'No auth provider found');
-			}
-
-			const normalizedProvider = auth_provider.value.toLowerCase();
-			const { providerInstance } = clientProviders[normalizedProvider];
-
-			if (!isRevocableProvider(providerInstance)) {
-				return error(
-					'Not Implemented',
-					'Provider does not support revocation'
-				);
-			}
-
-			try {
-				await providerInstance.revokeAccessToken(
-					user_refresh_token.value
-				);
-
-				onRevoke?.();
-
-				return new Response('Token revoked', {
-					status: 204
-				});
-			} catch (err) {
-				if (err instanceof Error) {
-					return error(
-						'Internal Server Error',
-						`Failed to revoke token: ${err.message}`
-					);
-				}
-
-				return error(
-					'Internal Server Error',
-					`Failed to revoke token: Unknown error: ${err}`
-				);
-			}
-		}
-	);