@absolutejs/auth 0.3.2 → 0.5.0

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/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}`
-				);
-			}
-		}
-	);

package/src/sessionStore.ts

@@ -1,10 +0,0 @@
-import { Elysia } from 'elysia';
-import { SessionRecord } from './types';
-
-export const sessionStore = <UserType>() => {
-	const initialSession: SessionRecord<UserType> = {};
-
-	return new Elysia({ name: 'sessionStore' }).state({
-		session: initialSession
-	});
-};

package/src/status.ts

@@ -1,100 +0,0 @@
-import { Elysia } from 'elysia';
-import { sessionStore } from './sessionStore';
-import { isRefreshableProvider } from './typeGuards';
-import { ClientProviders } from './types';
-
-type StatusProps = {
-	clientProviders: ClientProviders;
-	statusRoute?: string;
-	onStatus?: () => void;
-};
-
-export const status = <UserType>({
-	clientProviders,
-	statusRoute = 'auth-status',
-	onStatus
-}: StatusProps) =>
-	new Elysia()
-		.use(sessionStore<UserType>())
-		.get(
-			`/${statusRoute}`,
-			async ({
-				error,
-				cookie: { user_session_id, auth_provider },
-				store: { session }
-			}) => {
-				try {
-					if (user_session_id.value === undefined) {
-						return new Response(
-							JSON.stringify({ isLoggedIn: false, user: null }),
-							{
-								headers: { 'Content-Type': 'application/json' }
-							}
-						);
-					}
-
-					if (auth_provider.value === undefined) {
-						return new Response(
-							JSON.stringify({ isLoggedIn: false, user: null }),
-							{
-								headers: { 'Content-Type': 'application/json' }
-							}
-						);
-					}
-
-					const normalizedProvider =
-						auth_provider.value.toLowerCase();
-					const { providerInstance } =
-						clientProviders[normalizedProvider];
-
-					// Returns an error if the provider is not refreshable but
-					// consider another approach to be more inclusive of providers
-					if (!isRefreshableProvider(providerInstance)) {
-						return error(
-							'Not Implemented',
-							'Provider is not refreshable'
-						);
-					}
-
-					const userSession = session[user_session_id.value];
-					// console.log(
-					// 	'Session:',
-					// 	session,
-					// 	'User Session ID:',
-					// 	user_session_id.value
-					// );
-					// Return null because the user is not logged in, its not an error just a status
-					if (userSession === undefined) {
-						return new Response(
-							JSON.stringify({ isLoggedIn: false, user: null }),
-							{
-								headers: { 'Content-Type': 'application/json' }
-							}
-						);
-					}
-
-					const { user } = userSession;
-
-					onStatus?.();
-
-					return new Response(
-						JSON.stringify({ isLoggedIn: true, user }),
-						{
-							headers: { 'Content-Type': 'application/json' }
-						}
-					);
-				} catch (err) {
-					if (err instanceof Error) {
-						return error(
-							'Internal Server Error',
-							`Error: ${err.message} - ${err.stack ?? ''}`
-						);
-					}
-
-					return error(
-						'Internal Server Error',
-						`Unknown Error: ${err}`
-					);
-				}
-			}
-		);

package/src/typeGuards.ts

@@ -1,32 +0,0 @@
-import { OAuth2Tokens } from 'arctic';
-import { providers } from './providers';
-import { Providers } from './types';
-
-export const isRefreshableProvider = (
-	provider: InstanceType<(typeof providers)[Providers]>
-): provider is InstanceType<(typeof providers)[Providers]> & {
-	refreshAccessToken: () => Promise<OAuth2Tokens>;
-} =>
-	'refreshAccessToken' in provider &&
-	typeof provider.refreshAccessToken === 'function';
-
-export const isRevocableProvider = (
-	provider: InstanceType<(typeof providers)[Providers]>
-): provider is InstanceType<(typeof providers)[Providers]> & {
-	revokeAccessToken: (token: string) => Promise<void>;
-} =>
-	'revokeAccessToken' in provider &&
-	typeof provider.revokeAccessToken === 'function';
-
-export const isValidProviderKey = (
-	provider: string
-): provider is keyof typeof providers =>
-	Object.keys(providers)
-		.map((key) => key.toLowerCase())
-		.includes(provider.toLowerCase());
-
-export const isValidUser = <UserType>(user: unknown): user is UserType => true;
-
-export const isNonEmptyString = (
-	str: string | null | undefined
-): str is string => str !== null && str !== undefined && str.trim() !== '';

package/src/types.ts

@@ -1,78 +0,0 @@
-import { Cookie } from 'elysia';
-import { providers } from './providers';
-
-type SessionData<UserType> = {
-	user: UserType;
-	expiresAt: number;
-};
-
-type Oauth2ConfigOptions = {
-	[K in Providers]?: {
-		credentials: ConstructorParameters<(typeof providers)[K]>;
-		scopes?: string[];
-		searchParams?: [string, string][];
-	};
-};
-
-export type Providers = keyof typeof providers;
-
-export type SessionRecord<UserType> = Record<
-	string,
-	SessionData<UserType> | undefined
->;
-
-export type UserFunctionProps = {
-	authProvider: string;
-	decodedIdToken: {
-		[key: string]: string | undefined;
-	};
-};
-
-export type CreateUser<UserType> = ({
-	decodedIdToken,
-	authProvider
-}: UserFunctionProps) => Promise<UserType>;
-
-export type GetUser<UserType> = ({
-	decodedIdToken,
-	authProvider
-}: UserFunctionProps) => Promise<UserType | null>;
-
-export type OnCallback<UserType> = ({
-	authProvider,
-	decodedIdToken,
-	session,
-	user_session_id
-}: {
-	authProvider: string;
-	decodedIdToken: {
-		[key: string]: string | undefined;
-	};
-	session: SessionRecord<UserType>;
-	user_session_id: Cookie<string | undefined>;
-}) => void | Promise<void>;
-
-export type AbsoluteAuthProps<UserType> = {
-	config: Oauth2ConfigOptions;
-	authorizeRoute?: string;
-	callbackRoute?: string;
-	refreshRoute?: string;
-	revokeRoute?: string;
-	logoutRoute?: string;
-	statusRoute?: string;
-	onAuthorize?: () => void;
-	onCallback?: OnCallback<UserType>;
-	onStatus?: () => void;
-	onRefresh?: () => void;
-	onLogout?: () => void;
-	onRevoke?: () => void;
-};
-
-export type ClientProviders = Record<
-	string,
-	{
-		providerInstance: InstanceType<(typeof providers)[Providers]>;
-		scopes: string[];
-		searchParams: [string, string][];
-	}
->;

package/src/utils.ts

@@ -1,47 +0,0 @@
-import { Cookie } from 'elysia';
-import { MILLISECONDS_IN_A_DAY } from './constants';
-import { AbsoluteAuthProps, SessionRecord } from './types';
-import { isValidUser } from './typeGuards';
-
-type InsantiateUserSessionProps<UserType> = {
-	authProvider: string;
-	decodedIdToken: {
-		[key: string]: string | undefined;
-	};
-	session: SessionRecord<UserType>;
-	user_session_id: Cookie<string | undefined>;
-	createUser: () => UserType | Promise<UserType>;
-	getUser: () => UserType | Promise<UserType | null>;
-};
-
-export const instantiateUserSession = async <UserType>({
-	user_session_id,
-	session,
-	getUser,
-	createUser
-}: InsantiateUserSessionProps<UserType>) => {
-	let user = await getUser();
-	user = user ?? (await createUser());
-
-	// TODO : See if theres a better way to check valid user and not throw an error
-	if (!isValidUser<UserType>(user))
-		throw new Error('Internal Server Error - Invalid user schema');
-
-	const sessionKey = crypto.randomUUID();
-
-	session[sessionKey] = {
-		expiresAt: Date.now() + MILLISECONDS_IN_A_DAY,
-		user
-	};
-
-	user_session_id.set({
-		httpOnly: true,
-		sameSite: 'lax',
-		secure: true,
-		value: sessionKey
-	});
-};
-
-export const createAuthConfig = <UserType>(
-	props: AbsoluteAuthProps<UserType>
-) => props;

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ESNext",
-		"module": "ESNext",
-		"moduleResolution": "bundler",
-		"jsx": "react-jsx",
-		"esModuleInterop": true,
-		"forceConsistentCasingInFileNames": true,
-		"outDir": "dist",
-		"strict": true,
-		"declaration": true,
-		"skipLibCheck": true,
-		"lib": ["DOM", "DOM.Iterable", "ESNext"]
-	},
-	"include": ["src/**/*", "example/**/*"],
-	"exclude": ["node_modules"]
-}