@absolutejs/auth 0.2.4 → 0.2.5

package/src/refresh.ts

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,55 @@
+import { Cookie } from 'elysia';
+import { MILLISECONDS_IN_A_DAY } from './constants';
+import { AbsoluteAuthProps, CreateUser, GetUser, 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?: CreateUser<UserType>;
+	getUser?: GetUser<UserType>;
+};
+
+export const instantiateUserSession = async <UserType>({
+	authProvider,
+	decodedIdToken,
+	user_session_id,
+	session,
+	getUser,
+	createUser
+}: InsantiateUserSessionProps<UserType>) => {
+	let user = await getUser?.({
+		authProvider,
+		decodedIdToken
+	});
+	user = user ?? (await createUser?.({ authProvider, decodedIdToken }));
+
+	// 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
+	};
+	console.log('in func user_session_id before set', user_session_id.value);
+
+	user_session_id.set({
+		httpOnly: true,
+		sameSite: 'lax',
+		secure: true,
+		value: sessionKey
+	});
+
+	console.log('in func user_session_id after set', user_session_id.value);
+};
+
+export const createAuthConfig = <UserType>(
+	props: AbsoluteAuthProps<UserType>
+) => props;

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+	"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"]
+}

package/dist/example/components/AuthOptions.d.ts

@@ -1 +0,0 @@
-export declare const AuthOptions: () => import("react/jsx-runtime").JSX.Element;

package/dist/example/components/Example.d.ts

@@ -1 +0,0 @@
-export declare const Example: () => import("react/jsx-runtime").JSX.Element;

package/dist/example/components/Head.d.ts

@@ -1,6 +0,0 @@
-type HeadProps = {
-    title?: string;
-    icon?: string;
-};
-export declare const Head: ({ title, icon }: HeadProps) => import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/example/components/Modal.d.ts

@@ -1,8 +0,0 @@
-import { ReactNode } from 'react';
-type ModalProps = {
-    isOpen: boolean;
-    onClose: () => void;
-    children: ReactNode;
-};
-export declare const Modal: ({ isOpen, onClose, children }: ModalProps) => import("react/jsx-runtime").JSX.Element | null;
-export {};

package/dist/example/components/Navbar.d.ts

@@ -1,10 +0,0 @@
-import type { Dispatch, SetStateAction } from 'react';
-import type { User } from '../db/schema';
-type NavbarProps = {
-    user: User | undefined;
-    modalOpen: boolean;
-    handleLogOut: () => Promise<void>;
-    setModalOpen: Dispatch<SetStateAction<boolean>>;
-};
-export declare const Navbar: ({ user, handleLogOut, modalOpen, setModalOpen }: NavbarProps) => import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/example/components/NotAuthorized.d.ts

@@ -1 +0,0 @@
-export declare const NotAuthorized: () => import("react/jsx-runtime").JSX.Element;

package/dist/example/components/Protected.d.ts

@@ -1 +0,0 @@
-export declare const Protected: () => import("react/jsx-runtime").JSX.Element;

package/dist/example/db/migrate.d.ts

@@ -1 +0,0 @@
-export {};