@absolutejs/auth 0.24.0 → 0.25.0

package/dist/authSessionStores.d.ts

@@ -1,7 +1,7 @@
-import type { AbsoluteAuthSessionStore } from './sessionTypes';
+import type { AuthSessionStore } from './sessionTypes';
 import type { SessionData, UnregisteredSessionData, UserSessionId } from './types';
 export type CreateInMemoryAuthSessionStoreOptions<UserType> = {
     sessions?: Record<UserSessionId, SessionData<UserType>>;
     unregisteredSessions?: Record<UserSessionId, UnregisteredSessionData>;
 };
-export declare const createInMemoryAuthSessionStore: <UserType>(input?: CreateInMemoryAuthSessionStoreOptions<UserType>) => AbsoluteAuthSessionStore<UserType>;
+export declare const createInMemoryAuthSessionStore: <UserType>(input?: CreateInMemoryAuthSessionStoreOptions<UserType>) => AuthSessionStore<UserType>;

package/dist/callback.d.ts

@@ -1,8 +1,8 @@
 import { Elysia } from 'elysia';
-import type { AbsoluteAuthSessionStore } from './sessionTypes';
+import type { AuthSessionStore } from './sessionTypes';
 import { ClientProviders, OnCallbackError, OnCallbackSuccess, OnLinkConnector, OnLinkIdentity, OnLinkIdentityConflict, ResolveAuthIntent, RouteString } from './types';
 type CallbackProps<UserType> = {
-    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
+    authSessionStore?: AuthSessionStore<UserType>;
     clientProviders: ClientProviders;
     callbackRoute?: RouteString;
     resolveAuthIntent?: ResolveAuthIntent<UserType>;

package/dist/errors.d.ts

@@ -6,7 +6,7 @@ export type AuthIdentityConflict = {
     currentUserAuthSub?: string;
     intent?: AuthIntent;
 };
-export declare class AbsoluteAuthIdentityConflictError extends Error {
+export declare class AuthIdentityConflictError extends Error {
     conflict: AuthIdentityConflict;
     constructor(conflict: AuthIdentityConflict);
 }

package/dist/htmxRoutes.d.ts

@@ -1,8 +1,8 @@
 import { Elysia } from 'elysia';
-import type { AbsoluteAuthSessionStore } from './sessionTypes';
+import type { AuthSessionStore } from './sessionTypes';
 import type { AuthHtmxConfig, AuthHtmxUser } from './ui/types';
 export declare const createAuthHtmxRoutes: <UserType extends AuthHtmxUser>(config: AuthHtmxConfig & {
-    authSessionStore?: AbsoluteAuthSessionStore<UserType>;
+    authSessionStore?: AuthSessionStore<UserType>;
 }) => Elysia<"", {
     decorator: {};
     store: {

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 import { Elysia } from 'elysia';
-import { AbsoluteAuthProps } from './types';
+import { AuthConfig } from './types';
 import type { AuthHtmxUser } from './ui/types';
-export declare const absoluteAuth: <UserType extends AuthHtmxUser>({ providersConfiguration, authorizeRoute, callbackRoute, profileRoute, signoutRoute, statusRoute, refreshRoute, revokeRoute, cleanupIntervalMs, maxSessions, sessionDurationMs, authSessionStore, htmx, resolveAuthIntent, onAuthorizeSuccess, onAuthorizeError, onProfileSuccess, onProfileError, onCallbackSuccess, onLinkIdentity, onLinkIdentityConflict, onLinkConnector, onCallbackError, onStatus, onRefreshSuccess, onRefreshError, onSignOut, onRevocationSuccess, onRevocationError, onSessionCleanup }: AbsoluteAuthProps<UserType>) => Promise<Elysia<"", {
+export declare const auth: <UserType>({ providersConfiguration, authorizeRoute, callbackRoute, profileRoute, signoutRoute, statusRoute, refreshRoute, revokeRoute, cleanupIntervalMs, maxSessions, sessionDurationMs, authSessionStore, htmx, resolveAuthIntent, onAuthorizeSuccess, onAuthorizeError, onProfileSuccess, onProfileError, onCallbackSuccess, onLinkIdentity, onLinkIdentityConflict, onLinkConnector, onCallbackError, onStatus, onRefreshSuccess, onRefreshError, onSignOut, onRevocationSuccess, onRevocationError, onSessionCleanup }: AuthConfig<UserType>) => Promise<Elysia<"", {
     decorator: {};
     store: {
         session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<unknown>;
         unregisteredSession: import("./types").UnregisteredSessionRecord;
     } | {
-        session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<unknown>;
+        session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<unknown> & import("./types").SessionRecord<UserType & AuthHtmxUser>;
         unregisteredSession: import("./types").UnregisteredSessionRecord;
     };
     derive: {
@@ -20,7 +20,15 @@ export declare const absoluteAuth: <UserType extends AuthHtmxUser>({ providersCo
             readonly code: "Unauthorized";
             readonly message: "User is not authenticated";
         }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
-    };
+    } & ({} | {
+        readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType & AuthHtmxUser) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
+    });
     resolve: {};
 }, {
     typebox: {};
@@ -41,7 +49,7 @@ export declare const absoluteAuth: <UserType extends AuthHtmxUser>({ providersCo
     response: import("elysia").ExtractErrorFromHandle<{
         readonly cleanupSessions: () => Promise<void>;
     }>;
-} & {
+} & ({
     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}">>;
@@ -60,7 +68,40 @@ export declare const absoluteAuth: <UserType extends AuthHtmxUser>({ providersCo
             readonly message: "User is not authenticated";
         }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
     }>;
-}, (((({
+} & ({
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} | ({
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} & {
+    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 protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType & AuthHtmxUser) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
+    }>;
+}))), (((({
     [x: string]: {
         delete: {
             body: unknown;
@@ -731,9 +772,9 @@ export declare const absoluteAuth: <UserType extends AuthHtmxUser>({ providersCo
 }>>;
 export * from './types';
 export * from './typebox';
-export type { AbsoluteAuthSessionStore } from './sessionTypes';
+export type { AuthSessionStore } from './sessionTypes';
 export { isAuthIntent, isUserSessionId, isValidUser } from './typeGuards';
-export { AbsoluteAuthIdentityConflictError } from './errors';
+export { AuthIdentityConflictError } from './errors';
 export { sessionStore } from './sessionStore';
 export { createInMemoryAuthSessionStore } from './authSessionStores';
 export { createNeonAuthSessionStore } from './neonAuthSessionStore';

package/dist/index.js

@@ -2417,11 +2417,11 @@ var authorize = ({
 import { Elysia as Elysia3, t as t3 } from "elysia";
 
 // src/errors.ts
-class AbsoluteAuthIdentityConflictError extends Error {
+class AuthIdentityConflictError extends Error {
   conflict;
   constructor(conflict) {
     super(`${conflict.authProvider} identity ${conflict.providerSubject} is already linked to ${conflict.existingUserAuthSub}`);
-    this.name = "AbsoluteAuthIdentityConflictError";
+    this.name = "AuthIdentityConflictError";
     this.conflict = conflict;
   }
 }
@@ -2667,7 +2667,7 @@ var callback = ({
   try {
     response = authIntent === "link_identity" && onLinkIdentity ? await onLinkIdentity(callbackContext) : authIntent === "link_connector" && onLinkConnector ? await onLinkConnector(callbackContext) : await onCallbackSuccess?.(callbackContext);
   } catch (err) {
-    if (authIntent === "link_identity" && err instanceof AbsoluteAuthIdentityConflictError && onLinkIdentityConflict) {
+    if (authIntent === "link_identity" && err instanceof AuthIdentityConflictError && onLinkIdentityConflict) {
       response = await onLinkIdentityConflict({
         ...callbackContext,
         conflict: {
@@ -13860,8 +13860,8 @@ var instantiateUserSession = async ({
   };
   return response;
 };
-var createAuthConfiguration = (configuration) => configuration;
-var createProvidersConfiguration = (providersConfiguration) => providersConfiguration;
+var defineAuthConfig = (configuration) => configuration;
+var defineProvidersConfiguration = (providersConfiguration) => providersConfiguration;
 var getStatus = async (session, user_session_id) => {
   if (user_session_id === undefined) {
     return {
@@ -13925,7 +13925,7 @@ var getUserSessionId = ({
 };
 
 // src/index.ts
-var absoluteAuth = async ({
+var auth = async ({
   providersConfiguration,
   authorizeRoute,
   callbackRoute,
@@ -13985,18 +13985,21 @@ var absoluteAuth = async ({
     authSessionStore,
     callbackRoute,
     clientProviders,
-    resolveAuthIntent,
     onCallbackError,
     onCallbackSuccess,
+    onLinkConnector,
     onLinkIdentity,
     onLinkIdentityConflict,
-    onLinkConnector
+    resolveAuthIntent
   })).use(profile({
     clientProviders,
     onProfileError,
     onProfileSuccess,
     profileRoute
-  })).use(protectRoutePlugin({ authSessionStore })).use(htmx ? createAuthHtmxRoutes({ ...htmx, authSessionStore }) : new Elysia12);
+  })).use(protectRoutePlugin({ authSessionStore })).use(htmx ? createAuthHtmxRoutes({
+    ...htmx,
+    authSessionStore
+  }) : new Elysia12);
 };
 export {
   validateSession,
@@ -14030,8 +14033,9 @@ export {
   getUserSessionId,
   getStatus,
   extractPropFromIdentity,
+  defineProvidersConfiguration,
+  defineAuthConfig,
   decodeJWT,
-  createProvidersConfiguration,
   createOAuthLinkedProviderCredentialResolver,
   createNeonOAuthLinkedProviderCredentialResolver,
   createNeonLinkedProviderStores,
@@ -14040,14 +14044,13 @@ export {
   createInMemoryLinkedProviderStores,
   createInMemoryAuthSessionStore,
   createAuthHtmxRoutes,
-  createAuthConfiguration,
   buildClientProviders,
   authProviderOption,
   authIntentOption,
   authClientOption,
-  absoluteAuth,
-  AbsoluteAuthIdentityConflictError
+  auth,
+  AuthIdentityConflictError
 };
 
-//# debugId=D6887201B1B4B2A864756E2164756E21
+//# debugId=26C8391A6D84F55864756E2164756E21
 //# sourceMappingURL=index.js.map