@absolutejs/auth 0.25.1 → 0.26.0-beta.0

package/dist/{authorize.d.ts → routes/authorize.d.ts}

@@ -1,5 +1,5 @@
 import { Elysia } from 'elysia';
-import { AuthorizeRoute, ClientProviders, OnAuthorizeError, OnAuthorizeSuccess } from './types';
+import { AuthorizeRoute, ClientProviders, OnAuthorizeError, OnAuthorizeSuccess } from '../types';
 type AuthorizeProps = {
     clientProviders: ClientProviders;
     authorizeRoute?: AuthorizeRoute;
@@ -36,8 +36,8 @@ export declare const authorize: ({ clientProviders, authorizeRoute, onAuthorizeS
                 headers: unknown;
                 response: {
                     200: Response;
-                    400: "Provider is required" | "Cookies are missing";
-                    401: "Client provider not found" | "Client variant is required" | "Client variant not found" | "Provider is required";
+                    400: "Cookies are missing" | "Provider is required";
+                    401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found";
                     422: {
                         type: "validation";
                         on: string;
@@ -68,8 +68,8 @@ export declare const authorize: ({ clientProviders, authorizeRoute, onAuthorizeS
                     headers: unknown;
                     response: {
                         200: Response;
-                        400: "Provider is required" | "Cookies are missing";
-                        401: "Client provider not found" | "Client variant is required" | "Client variant not found" | "Provider is required";
+                        400: "Cookies are missing" | "Provider is required";
+                        401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found";
                         422: {
                             type: "validation";
                             on: string;

package/dist/{callback.d.ts → routes/callback.d.ts}

@@ -1,6 +1,6 @@
 import { Elysia } from 'elysia';
-import type { AuthSessionStore } from './sessionTypes';
-import { ClientProviders, OnCallbackError, OnCallbackSuccess, OnLinkConnector, OnLinkIdentity, OnLinkIdentityConflict, ResolveAuthIntent, RouteString } from './types';
+import type { AuthSessionStore } from '../session/types';
+import { ClientProviders, OnCallbackError, OnCallbackSuccess, OnLinkConnector, OnLinkIdentity, OnLinkIdentityConflict, ResolveAuthIntent, RouteString } from '../types';
 type CallbackProps<UserType> = {
     authSessionStore?: AuthSessionStore<UserType>;
     clientProviders: ClientProviders;
@@ -15,8 +15,8 @@ type CallbackProps<UserType> = {
 export declare const callback: <UserType>({ authSessionStore, clientProviders, callbackRoute, resolveAuthIntent, onCallbackSuccess, onLinkIdentity, onLinkIdentityConflict, onLinkConnector, onCallbackError }: CallbackProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("./types").SessionRecord<UserType>;
-        unregisteredSession: import("./types").UnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {};
     resolve: {};

package/dist/{profile.d.ts → routes/profile.d.ts}

@@ -1,5 +1,5 @@
 import { Elysia } from 'elysia';
-import { ClientProviders, OnProfileError, OnProfileSuccess, RouteString } from './types';
+import { ClientProviders, OnProfileError, OnProfileSuccess, RouteString } from '../types';
 type ProfileProps = {
     clientProviders: ClientProviders;
     profileRoute?: RouteString;
@@ -9,8 +9,8 @@ type ProfileProps = {
 export declare const profile: <UserType>({ clientProviders, profileRoute, onProfileSuccess, onProfileError }: ProfileProps) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("./types").SessionRecord<UserType>;
-        unregisteredSession: import("./types").UnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {};
     resolve: {};
@@ -33,8 +33,8 @@ export declare const profile: <UserType>({ clientProviders, profileRoute, onProf
             headers: unknown;
             response: {
                 200: Response;
-                400: "Cookies are missing";
-                401: "Client provider not found" | "Client variant is required" | "Client variant not found" | "Provider is required" | "No auth provider found" | "Invalid provider" | "No user session found";
+                400: "Cookies are missing" | "Session has no access token to fetch a profile";
+                401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found" | "No auth provider found" | "Invalid provider" | "No user session found";
                 422: {
                     type: "validation";
                     on: string;

package/dist/{protectRoute.d.ts → routes/protectRoute.d.ts}

@@ -1,5 +1,5 @@
 import { Elysia } from 'elysia';
-import type { AuthSessionStore } from './sessionTypes';
+import type { AuthSessionStore } from '../session/types';
 type AuthFailError = {
     readonly code: 'Bad Request';
     readonly message: 'Cookies are missing';
@@ -12,11 +12,11 @@ export declare const protectRoutePlugin: <UserType>({ authSessionStore }?: {
 }) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("./types").SessionRecord<UserType>;
-        unregisteredSession: import("./types").UnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {
-        readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AuthFailError) => AuthFailReturn) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | AuthReturn | NonNullable<AuthFailReturn> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401>>;
+        readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AuthFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | NonNullable<AuthFailReturn> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401>>;
     };
     resolve: {};
 }, {
@@ -33,7 +33,7 @@ export declare const protectRoutePlugin: <UserType>({ authSessionStore }?: {
     macroFn: {};
     parser: {};
     response: import("elysia").ExtractErrorFromHandle<{
-        readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AuthFailError) => AuthFailReturn) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | AuthReturn | NonNullable<AuthFailReturn> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401>>;
+        readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AuthFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | NonNullable<AuthFailReturn> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401>>;
     }>;
 }, {}, {
     derive: {};

package/dist/{refresh.d.ts → routes/refresh.d.ts}

@@ -1,6 +1,6 @@
 import { Elysia } from 'elysia';
-import type { AuthSessionStore } from './sessionTypes';
-import { ClientProviders, OnRefreshError, OnRefreshSuccess, RouteString } from './types';
+import type { AuthSessionStore } from '../session/types';
+import { ClientProviders, OnRefreshError, OnRefreshSuccess, RouteString } from '../types';
 type RefreshProps<UserType> = {
     authSessionStore?: AuthSessionStore<UserType>;
     clientProviders: ClientProviders;
@@ -12,8 +12,8 @@ type RefreshProps<UserType> = {
 export declare const refresh: <UserType>({ authSessionStore, clientProviders, refreshRoute, onRefreshSuccess, onRefreshError, sessionDurationMs }: RefreshProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("./types").SessionRecord<UserType>;
-        unregisteredSession: import("./types").UnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {};
     resolve: {};
@@ -37,7 +37,7 @@ export declare const refresh: <UserType>({ authSessionStore, clientProviders, re
             response: {
                 200: Response;
                 400: "Cookies are missing" | "Invalid provider" | "No refresh token found";
-                401: "Client provider not found" | "Client variant is required" | "Client variant not found" | "Provider is required" | "No auth provider found" | "No user session found";
+                401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found" | "No auth provider found" | "No user session found";
                 422: {
                     type: "validation";
                     on: string;

package/dist/{revoke.d.ts → routes/revoke.d.ts}

@@ -1,6 +1,6 @@
 import { Elysia } from 'elysia';
-import type { AuthSessionStore } from './sessionTypes';
-import { ClientProviders, OnRevocationError, OnRevocationSuccess, RouteString } from './types';
+import type { AuthSessionStore } from '../session/types';
+import { ClientProviders, OnRevocationError, OnRevocationSuccess, RouteString } from '../types';
 type RevokeProps<UserType> = {
     authSessionStore?: AuthSessionStore<UserType>;
     clientProviders: ClientProviders;
@@ -11,8 +11,8 @@ type RevokeProps<UserType> = {
 export declare const revoke: <UserType>({ authSessionStore, clientProviders, revokeRoute, onRevocationSuccess, onRevocationError }: RevokeProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("./types").SessionRecord<UserType>;
-        unregisteredSession: import("./types").UnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {};
     resolve: {};
@@ -35,8 +35,8 @@ export declare const revoke: <UserType>({ authSessionStore, clientProviders, rev
             headers: unknown;
             response: {
                 200: Response;
-                400: "Cookies are missing" | "Invalid provider";
-                401: "Client provider not found" | "Client variant is required" | "Client variant not found" | "Provider is required" | "No auth provider found" | "No user session found";
+                400: "Cookies are missing" | "Invalid provider" | "Session has no access token to revoke";
+                401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found" | "No auth provider found" | "No user session found";
                 422: {
                     type: "validation";
                     on: string;

package/dist/routes/sessions.d.ts

@@ -0,0 +1,103 @@
+import { Elysia } from 'elysia';
+import type { SessionsRouteProps } from '../session/sessionsConfig';
+import type { UserSessionId } from '../types';
+type SessionSummary = {
+    authenticatedAt?: number;
+    current: boolean;
+    expiresAt: number;
+    id: UserSessionId;
+};
+export declare const sessionRoutes: <UserType>({ authSessionStore, getUserId, sessionsRoute }: SessionsRouteProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    readonly sessions: SessionSummary[];
+                };
+                401: "Authentication required";
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+                501: "Session management requires an authSessionStore";
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":id": {
+            delete: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        readonly revoked: `${string}-${string}-${string}-${string}-${string}`;
+                    };
+                    400: "Invalid session id";
+                    401: "Authentication required";
+                    404: "Session not found";
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                    501: "Session management requires an authSessionStore";
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/{signout.d.ts → routes/signout.d.ts}

@@ -1,6 +1,6 @@
 import { Elysia } from 'elysia';
-import type { AuthSessionStore } from './sessionTypes';
-import { OnSignOut, RouteString } from './types';
+import type { AuthSessionStore } from '../session/types';
+import { OnSignOut, RouteString } from '../types';
 type SignOutProps<UserType> = {
     authSessionStore?: AuthSessionStore<UserType>;
     signoutRoute?: RouteString;
@@ -9,8 +9,8 @@ type SignOutProps<UserType> = {
 export declare const signout: <UserType>({ authSessionStore, signoutRoute, onSignOut }: SignOutProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("./types").SessionRecord<UserType>;
-        unregisteredSession: import("./types").UnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {};
     resolve: {};

package/dist/routes/stepUp.d.ts

@@ -0,0 +1,48 @@
+import { Elysia } from 'elysia';
+import type { AuthSessionStore } from '../session/types';
+type ReauthFailError = {
+    readonly code: 'Unauthorized';
+    readonly message: 'Recent authentication required';
+};
+export declare const stepUpPlugin: <UserType>({ authSessionStore }?: {
+    authSessionStore?: AuthSessionStore<UserType>;
+}) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {
+        readonly requireRecentAuth: <AuthReturn, AuthFailReturn>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: ReauthFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | NonNullable<AuthFailReturn>>;
+    };
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: import("elysia").UnwrapRoute<{
+        cookie: import("@sinclair/typebox").TObject<{
+            user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
+        }>;
+    }, {}, "">;
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly requireRecentAuth: <AuthReturn, AuthFailReturn>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: ReauthFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | NonNullable<AuthFailReturn>>;
+    }>;
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/{userStatus.d.ts → routes/userStatus.d.ts}

@@ -1,6 +1,6 @@
 import { Elysia } from 'elysia';
-import type { AuthSessionStore } from './sessionTypes';
-import { OnStatus, RouteString } from './types';
+import type { AuthSessionStore } from '../session/types';
+import { OnStatus, RouteString } from '../types';
 type StatusProps<UserType> = {
     authSessionStore?: AuthSessionStore<UserType>;
     statusRoute?: RouteString;
@@ -9,8 +9,8 @@ type StatusProps<UserType> = {
 export declare const userStatus: <UserType>({ authSessionStore, statusRoute, onStatus }: StatusProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("./types").SessionRecord<UserType>;
-        unregisteredSession: import("./types").UnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {};
     resolve: {};

package/dist/{sessionAccess.d.ts → session/access.d.ts}

@@ -1,12 +1,14 @@
 import type { Cookie } from 'elysia';
-import type { AuthSessionStore } from './sessionTypes';
-import type { SessionData, SessionRecord, UnregisteredSessionRecord, UserSessionId } from './types';
-export declare const loadSessionFromSource: <UserType>({ authSessionStore, session, userSessionId, removeExpired }: {
+import type { SessionData, SessionRecord, UnregisteredSessionRecord, UserSessionId } from '../types';
+import type { AuthSessionStore } from './types';
+export declare const createSessionCompatibilityLayer: <UserType>({ authSessionStore, userSessionId }: {
     authSessionStore?: AuthSessionStore<UserType>;
-    session?: SessionRecord<UserType>;
     userSessionId?: UserSessionId;
-    removeExpired?: boolean;
-}) => Promise<SessionData<UserType> | undefined>;
+}) => Promise<{
+    session: SessionRecord<UserType>;
+    unregisteredSession: UnregisteredSessionRecord;
+    persist: () => Promise<void>;
+}>;
 export declare const getStatusFromSource: <UserType>({ authSessionStore, session, user_session_id }: {
     authSessionStore?: AuthSessionStore<UserType>;
     session?: SessionRecord<UserType>;
@@ -21,11 +23,9 @@ export declare const getStatusFromSource: <UserType>({ authSessionStore, session
     error: null;
     user: NonNullable<UserType> | null;
 }>;
-export declare const createSessionCompatibilityLayer: <UserType>({ authSessionStore, userSessionId }: {
+export declare const loadSessionFromSource: <UserType>({ authSessionStore, session, userSessionId, removeExpired }: {
     authSessionStore?: AuthSessionStore<UserType>;
+    session?: SessionRecord<UserType>;
     userSessionId?: UserSessionId;
-}) => Promise<{
-    session: SessionRecord<UserType>;
-    unregisteredSession: UnregisteredSessionRecord;
-    persist: () => Promise<void>;
-}>;
+    removeExpired?: boolean;
+}) => Promise<SessionData<UserType> | undefined>;

package/dist/{sessionCleanup.d.ts → session/cleanup.d.ts}

@@ -1,6 +1,6 @@
 import { Elysia } from 'elysia';
-import type { AuthSessionStore } from './sessionTypes';
-import type { OnSessionCleanup, SessionRecord, UnregisteredSessionRecord } from './types';
+import type { OnSessionCleanup, SessionRecord, UnregisteredSessionRecord } from '../types';
+import type { AuthSessionStore } from './types';
 type SessionCleanupProps<UserType> = {
     authSessionStore?: AuthSessionStore<UserType>;
     cleanupIntervalMs?: number;

package/dist/{authSessionStores.d.ts → session/inMemoryStore.d.ts}

@@ -1,5 +1,5 @@
-import type { AuthSessionStore } from './sessionTypes';
-import type { SessionData, UnregisteredSessionData, UserSessionId } from './types';
+import type { SessionData, UnregisteredSessionData, UserSessionId } from '../types';
+import type { AuthSessionStore } from './types';
 export type CreateInMemoryAuthSessionStoreOptions<UserType> = {
     sessions?: Record<UserSessionId, SessionData<UserType>>;
     unregisteredSessions?: Record<UserSessionId, UnregisteredSessionData>;