@absolutejs/auth 0.65.1 → 0.65.3

package/dist/session/access.d.ts

@@ -0,0 +1,33 @@
+import type { Cookie } from 'elysia';
+import type { SessionData, SessionRecord, UnregisteredSessionRecord, UserSessionId } from '../types';
+import type { AuthSessionSource, AuthSessionStore } from './types';
+export declare const createSessionCompatibilityLayer: <UserType>({ authSessionStore, userSessionId }: {
+    authSessionStore?: AuthSessionStore<UserType>;
+    userSessionId?: UserSessionId;
+}) => Promise<{
+    session: SessionRecord<UserType>;
+    unregisteredSession: UnregisteredSessionRecord;
+    persist: () => Promise<void>;
+}>;
+export declare const getStatusFromSource: <UserType>({ authSessionStore, session, user_session_id }: {
+    authSessionStore?: AuthSessionSource<UserType>;
+    session?: SessionRecord<UserType>;
+    user_session_id: Cookie<UserSessionId | undefined>;
+}) => Promise<{
+    error: {
+        readonly code: "Bad Request";
+        readonly message: "Cookies are missing";
+    };
+    user: null;
+    impersonator?: undefined;
+} | {
+    error: null;
+    impersonator: import("..").Impersonator | undefined;
+    user: NonNullable<UserType> | null;
+}>;
+export declare const loadSessionFromSource: <UserType>({ authSessionStore, session, userSessionId, removeExpired }: {
+    authSessionStore?: AuthSessionSource<UserType>;
+    session?: SessionRecord<UserType>;
+    userSessionId?: UserSessionId;
+    removeExpired?: boolean;
+}) => Promise<SessionData<UserType> | undefined>;

package/dist/session/anonymous.d.ts

@@ -0,0 +1,12 @@
+import type { Cookie } from 'elysia';
+import type { SessionData, SessionRecord, UserSessionId } from '../types';
+import type { AuthSessionStore } from './types';
+export declare const createAnonymousSession: <UserType>({ authSessionStore, cookie, cookieSecure, guestUser, inMemorySession, sessionDurationMs }: {
+    authSessionStore?: AuthSessionStore<UserType>;
+    cookie: Cookie<UserSessionId | undefined>;
+    cookieSecure?: boolean;
+    guestUser: UserType;
+    inMemorySession: SessionRecord<UserType>;
+    sessionDurationMs?: number;
+}) => Promise<`${string}-${string}-${string}-${string}-${string}`>;
+export declare const isAnonymousSession: <UserType>(session: SessionData<UserType> | undefined) => boolean;

package/dist/session/cleanup.d.ts

@@ -0,0 +1,45 @@
+import { Elysia } from 'elysia';
+import type { OnSessionCleanup, SessionRecord, UnregisteredSessionRecord } from '../types';
+import type { AuthSessionStore } from './types';
+type SessionCleanupProps<UserType> = {
+    authSessionStore?: AuthSessionStore<UserType>;
+    cleanupIntervalMs?: number;
+    maxSessions?: number;
+    onSessionCleanup?: OnSessionCleanup<UserType>;
+};
+export declare const sessionCleanup: <UserType>({ authSessionStore, cleanupIntervalMs, maxSessions, onSessionCleanup }: SessionCleanupProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: SessionRecord<UserType>;
+        unregisteredSession: UnregisteredSessionRecord;
+    };
+    derive: {
+        readonly cleanupSessions: () => Promise<void>;
+    };
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly cleanupSessions: () => Promise<void>;
+    }>;
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/session/cookieReader.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Read the raw `user_session_id` cookie value from a request's Cookie header.
+ * Returns the (URL-decoded) value, or null when absent. Anchored so decoy
+ * cookies cannot shadow the real one. Validate the result with `isUserSessionId`
+ * before trusting it — this only parses, it does not vouch for the format.
+ *
+ * Use this instead of hand-rolling a Cookie-header regex in each consumer, so
+ * the anchoring lives in exactly one place.
+ */
+export declare const readSessionCookie: (request: Request) => string | null;

package/dist/session/impersonation.d.ts

@@ -0,0 +1,34 @@
+import type { Cookie } from 'elysia';
+import type { AuditEvent } from '../audit/types';
+import type { SessionData, SessionRecord, UserSessionId } from '../types';
+import type { AuthSessionStore } from './types';
+type Emit = (event: AuditEvent) => Promise<void> | void;
+export declare const endImpersonation: <UserType>({ authSessionStore, cookie, cookieSecure, emit, inMemorySession }: {
+    authSessionStore?: AuthSessionStore<UserType>;
+    cookie: Cookie<UserSessionId | undefined>;
+    cookieSecure?: boolean;
+    emit?: Emit;
+    inMemorySession: SessionRecord<UserType>;
+}) => Promise<{
+    restored: boolean;
+}>;
+export declare const isImpersonating: <UserType>(session: SessionData<UserType> | undefined) => boolean;
+export declare const startImpersonation: <UserType>({ allowNested, authSessionStore, cookie, cookieSecure, emit, getUserId, impersonator, inMemorySession, sessionDurationMs, user }: {
+    allowNested?: boolean;
+    authSessionStore?: AuthSessionStore<UserType>;
+    cookie: Cookie<UserSessionId | undefined>;
+    cookieSecure?: boolean;
+    emit?: Emit;
+    getUserId?: (user: UserType) => string;
+    impersonator: {
+        actorEmail?: string;
+        actorId: string;
+        readOnly?: boolean;
+        reason: string;
+        suppressSideEffects?: boolean;
+    };
+    inMemorySession: SessionRecord<UserType>;
+    sessionDurationMs?: number;
+    user: UserType;
+}) => Promise<`${string}-${string}-${string}-${string}-${string}`>;
+export {};

package/dist/session/inMemoryStore.d.ts

@@ -0,0 +1,7 @@
+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>;
+};
+export declare const createInMemoryAuthSessionStore: <UserType>(input?: CreateInMemoryAuthSessionStoreOptions<UserType>) => AuthSessionStore<UserType>;

package/dist/session/multiSession.d.ts

@@ -0,0 +1,27 @@
+import type { Cookie } from 'elysia';
+import type { SessionRecord, UserSessionId } from '../types';
+import type { AuthSessionStore } from './types';
+export declare const addToSessionRing: (ring: Cookie<string | undefined>, sessionId: UserSessionId, cookieSecure?: boolean) => Cookie<string | undefined>;
+export declare const listRingSessions: <UserType>({ authSessionStore, inMemorySession, ring }: {
+    authSessionStore?: AuthSessionStore<UserType>;
+    inMemorySession?: SessionRecord<UserType>;
+    ring: Cookie<string | undefined>;
+}) => Promise<{
+    sessionId: UserSessionId;
+    user: UserType;
+}[]>;
+export declare const readSessionRing: (ring: Cookie<string | undefined>) => `${string}-${string}-${string}-${string}-${string}`[];
+export declare const removeFromSessionRing: <UserType>({ activeCookie, authSessionStore, cookieSecure, inMemorySession, ring, sessionId }: {
+    activeCookie?: Cookie<UserSessionId | undefined>;
+    authSessionStore?: AuthSessionStore<UserType>;
+    cookieSecure?: boolean;
+    inMemorySession?: SessionRecord<UserType>;
+    ring: Cookie<string | undefined>;
+    sessionId: UserSessionId;
+}) => Promise<void>;
+export declare const switchActiveSession: ({ activeCookie, cookieSecure, ring, sessionId }: {
+    activeCookie: Cookie<UserSessionId | undefined>;
+    cookieSecure?: boolean;
+    ring: Cookie<string | undefined>;
+    sessionId: UserSessionId;
+}) => boolean;