@absolutejs/auth 0.75.4 → 0.75.5

package/dist/routes/protectRoute.d.ts

@@ -1,4 +1,4 @@
-import { Elysia } from 'elysia';
+import { Elysia, StatusMap, type ElysiaStatus } from 'elysia';
 import type { AuthSessionSource } from '../session/types';
 import { type AccessTokenPrincipalConfig, type AuthPrincipal } from '../principal';
 type AuthFailError = {
@@ -8,6 +8,11 @@ type AuthFailError = {
     readonly code: 'Unauthorized';
     readonly message: 'User is not authenticated';
 };
+type AuthFailureResponse = ElysiaStatus<'Bad Request', 'Cookies are missing', (typeof StatusMap)['Bad Request']> | ElysiaStatus<'Unauthorized', 'User is not authenticated', (typeof StatusMap)['Unauthorized']>;
+type ProtectRoute<UserType> = {
+    <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => Promise<AuthReturn>, handleAuthFail?: (error: AuthFailError) => AuthFailReturn): Promise<AuthFailureResponse | AuthReturn | Awaited<AuthFailReturn>>;
+    <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn, handleAuthFail?: (error: AuthFailError) => AuthFailReturn): Promise<AuthFailureResponse | AuthReturn | Awaited<AuthFailReturn>>;
+};
 export declare const protectRoutePlugin: <UserType>({ accessTokens, authSessionStore }?: {
     accessTokens?: AccessTokenPrincipalConfig<UserType>;
     authSessionStore?: AuthSessionSource<UserType>;
@@ -18,8 +23,21 @@ export declare const protectRoutePlugin: <UserType>({ accessTokens, authSessionS
         unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {
+        readonly absoluteAuthStatus: {
+            error: {
+                readonly code: "Bad Request";
+                readonly message: "Cookies are missing";
+            };
+            user: null;
+            impersonator?: undefined;
+        } | {
+            error: null;
+            impersonator: import("..").Impersonator | undefined;
+            user: NonNullable<UserType> | null;
+        };
         readonly authPrincipal: AuthPrincipal<UserType> | undefined;
-        readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AuthFailError) => AuthFailReturn) => import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | AuthReturn | Promise<AuthReturn> | NonNullable<AuthFailReturn>;
+    } & {
+        readonly protectRoute: ProtectRoute<UserType>;
     };
 }, {
     typebox: {};
@@ -36,8 +54,7 @@ export declare const protectRoutePlugin: <UserType>({ accessTokens, authSessionS
     macroFn: {};
     parser: {};
     response: import("elysia/types").ExtractErrorFromHandle<{
-        readonly authPrincipal: AuthPrincipal<UserType> | undefined;
-        readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AuthFailError) => AuthFailReturn) => import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | AuthReturn | Promise<AuthReturn> | NonNullable<AuthFailReturn>;
+        readonly protectRoute: ProtectRoute<UserType>;
     }>;
 }, {}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral>;
 export {};

package/dist/routes/stepUp.d.ts

@@ -1,9 +1,14 @@
-import { Elysia } from 'elysia';
+import { Elysia, StatusMap, type ElysiaStatus } from 'elysia';
 import type { AuthSessionSource } from '../session/types';
 type ReauthFailError = {
     readonly code: 'Unauthorized';
     readonly message: 'Recent authentication required';
 };
+type ReauthFailureResponse = ElysiaStatus<'Unauthorized', 'Recent authentication required', (typeof StatusMap)['Unauthorized']>;
+type RequireRecentAuth<UserType> = {
+    <AuthReturn, AuthFailReturn = never>(maxAgeMs: number, handleAuth: (user: UserType) => Promise<AuthReturn>, handleAuthFail?: (error: ReauthFailError) => AuthFailReturn): Promise<ReauthFailureResponse | AuthReturn | Awaited<AuthFailReturn>>;
+    <AuthReturn, AuthFailReturn = never>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn, handleAuthFail?: (error: ReauthFailError) => AuthFailReturn): Promise<ReauthFailureResponse | AuthReturn | Awaited<AuthFailReturn>>;
+};
 export declare const stepUpPlugin: <UserType>({ authSessionStore }?: {
     authSessionStore?: AuthSessionSource<UserType>;
 }) => Elysia<"", "local", {
@@ -13,7 +18,7 @@ export declare const stepUpPlugin: <UserType>({ authSessionStore }?: {
         unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {
-        readonly requireRecentAuth: <AuthReturn, AuthFailReturn>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: ReauthFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | NonNullable<AuthFailReturn>>;
+        readonly requireRecentAuth: RequireRecentAuth<UserType>;
     };
 }, {
     typebox: {};
@@ -30,7 +35,7 @@ export declare const stepUpPlugin: <UserType>({ authSessionStore }?: {
     macroFn: {};
     parser: {};
     response: import("elysia/types").ExtractErrorFromHandle<{
-        readonly requireRecentAuth: <AuthReturn, AuthFailReturn>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: ReauthFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | NonNullable<AuthFailReturn>>;
+        readonly requireRecentAuth: RequireRecentAuth<UserType>;
     }>;
 }, {}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral>;
 export {};

package/dist/server.js

@@ -4366,8 +4366,8 @@ var failureResponse = (config, failure, requiredScopes) => new Response(JSON.str
 var agentAuthContextPlugin = (config) => new Elysia2({
   name: "@absolutejs/auth/agent-context",
   seed: pluginDependencySeed(config)
-}).derive(({ request }) => ({
-  protectAgent: async (requiredScopes, handleAuth, handleAuthFail) => {
+}).derive(({ request }) => {
+  const protectAgent = async (requiredScopes, handleAuth, handleAuthFail) => {
     if (config === undefined) {
       const failure = {
         code: "Unauthorized",
@@ -4393,8 +4393,9 @@ var agentAuthContextPlugin = (config) => new Elysia2({
       return await handleAuthFail?.(failure) ?? failureResponse(config, failure, requiredScopes);
     }
     return handleAuth(principal);
-  }
-})).as("global");
+  };
+  return { protectAgent };
+}).as("global");
 
 // src/agents/oauthGuide.ts
 var DEFAULT_GUIDE_ROUTE = "/auth.md";
@@ -5605,17 +5606,17 @@ var protectPermissionPlugin = ({
 }).use(sessionStore()).guard({
   cookie: t3.Cookie({ user_session_id: userSessionIdTypebox }),
   schema: "merge"
-}).derive(({ store: { session }, cookie: { user_session_id }, status }) => ({
-  protectPermission: (check, handleAuth, handleAuthFail) => getStatusFromSource({
+}).derive(({ store: { session }, cookie: { user_session_id }, status }) => {
+  const protectPermission = (check, handleAuth, handleAuthFail) => getStatusFromSource({
     authSessionStore,
     session,
     user_session_id
   }).then(async ({ user, error }) => {
     if (error) {
-      return handleAuthFail?.(error) ?? status(error.code, error.message);
+      return await handleAuthFail?.(error) ?? status(error.code, error.message);
     }
     if (!user) {
-      return handleAuthFail?.({
+      return await handleAuthFail?.({
         code: "Unauthorized",
         message: "User is not authenticated"
       }) ?? status("Unauthorized", "User is not authenticated");
@@ -5632,14 +5633,15 @@ var protectPermissionPlugin = ({
         organizationId: check.organizationId,
         type: "authorization_denied"
       });
-      return handleAuthFail?.({
+      return await handleAuthFail?.({
         code: "Forbidden",
         message: "Insufficient permissions"
       }) ?? status("Forbidden", "Insufficient permissions");
     }
     return handleAuth(user);
-  })
-})).as("global");
+  });
+  return { protectPermission };
+}).as("global");
 
 // src/routes/protectRoute.ts
 import { Elysia as Elysia6, t as t4 } from "elysia";
@@ -5703,8 +5705,7 @@ var protectRoutePlugin = ({
 }).derive(async ({
   store: { session },
   cookie: { user_session_id },
-  headers,
-  status
+  headers
 }) => {
   const sessionStatus = await getStatusFromSource({
     authSessionStore,
@@ -5723,25 +5724,30 @@ var protectRoutePlugin = ({
       authorization: headers.authorization,
       config: accessTokens
     });
-  return {
-    authPrincipal,
-    protectRoute: (handleAuth, handleAuthFail) => {
-      const user = authPrincipal?.user;
-      const { error } = sessionStatus;
-      if (error) {
-        if (user)
-          return handleAuth(user);
-        return handleAuthFail?.(error) ?? status(error.code, error.message);
-      }
-      if (!user) {
-        return handleAuthFail?.({
-          code: "Unauthorized",
-          message: "User is not authenticated"
-        }) ?? status("Unauthorized", "User is not authenticated");
-      }
-      return handleAuth(user);
+  return { absoluteAuthStatus: sessionStatus, authPrincipal };
+}).derive(({ absoluteAuthStatus, authPrincipal, status }) => {
+  const protectRoute = async (handleAuth, handleAuthFail) => {
+    if (!absoluteAuthStatus)
+      return await handleAuthFail?.({
+        code: "Unauthorized",
+        message: "User is not authenticated"
+      }) ?? status("Unauthorized", "User is not authenticated");
+    const user = authPrincipal?.user;
+    const { error } = absoluteAuthStatus;
+    if (error) {
+      if (user)
+        return handleAuth(user);
+      return await handleAuthFail?.(error) ?? status(error.code, error.message);
+    }
+    if (!user) {
+      return await handleAuthFail?.({
+        code: "Unauthorized",
+        message: "User is not authenticated"
+      }) ?? status("Unauthorized", "User is not authenticated");
     }
+    return handleAuth(user);
   };
+  return { protectRoute };
 }).as("global");
 
 // src/routes/stepUp.ts
@@ -5754,23 +5760,24 @@ var stepUpPlugin = ({
 }).use(sessionStore()).guard({
   cookie: t5.Cookie({ user_session_id: userSessionIdTypebox }),
   schema: "merge"
-}).derive(({ store: { session }, cookie: { user_session_id }, status }) => ({
-  requireRecentAuth: (maxAgeMs, handleAuth, handleAuthFail) => loadSessionFromSource({
+}).derive(({ store: { session }, cookie: { user_session_id }, status }) => {
+  const requireRecentAuth = (maxAgeMs, handleAuth, handleAuthFail) => loadSessionFromSource({
     authSessionStore,
     session,
     userSessionId: user_session_id.value
-  }).then((userSession) => {
+  }).then(async (userSession) => {
     const authenticatedAt = userSession?.authenticatedAt;
     const isRecent = authenticatedAt !== undefined && Date.now() - authenticatedAt <= maxAgeMs;
     if (!userSession || !isRecent) {
-      return handleAuthFail?.({
+      return await handleAuthFail?.({
         code: "Unauthorized",
         message: "Recent authentication required"
       }) ?? status("Unauthorized", "Recent authentication required");
     }
     return handleAuth(userSession.user);
-  })
-})).as("global");
+  });
+  return { requireRecentAuth };
+}).as("global");
 
 // src/oidc/socketTickets.ts
 init_crypto();
@@ -41672,5 +41679,5 @@ export {
   VerificationProviderError
 };
 
-//# debugId=A14F7F9FF66E9B8A64756E2164756E21
+//# debugId=81F68CD916C89A2764756E2164756E21
 //# sourceMappingURL=server.js.map