@absolutejs/auth 0.65.1 → 0.65.3

package/dist/client/createAuthClient.d.ts

@@ -0,0 +1,285 @@
+import type { PublicKeyCredentialCreationOptionsJSON, PublicKeyCredentialRequestOptionsJSON } from '@simplewebauthn/browser';
+export type AuthClientError = {
+    body: unknown;
+    message: string;
+    status: number;
+};
+export type AuthClientResult<T> = {
+    data: null;
+    error: AuthClientError;
+} | {
+    data: T;
+    error: null;
+};
+export type AuthClientRoutes = {
+    emailVerify?: string;
+    emailVerifyRequest?: string;
+    login?: string;
+    magicLinkRequest?: string;
+    magicLinkVerify?: string;
+    mfaChallenge?: string;
+    mfaManagement?: string;
+    mfaSetup?: string;
+    mfaVerifySetup?: string;
+    passkeyAuthenticateOptions?: string;
+    passkeyAuthenticateVerify?: string;
+    passkeyList?: string;
+    passkeyRegisterOptions?: string;
+    passkeyRegisterVerify?: string;
+    passkeyRemove?: string;
+    passwordReset?: string;
+    passwordResetRequest?: string;
+    register?: string;
+    sessions?: string;
+    signout?: string;
+    status?: string;
+};
+export type AuthClientConfig = {
+    baseUrl?: string;
+    credentials?: RequestCredentials;
+    fetch?: typeof fetch;
+    routes?: AuthClientRoutes;
+};
+export declare const createAuthClient: ({ baseUrl, credentials, fetch: fetchImpl, routes }?: AuthClientConfig) => {
+    emailVerification: {
+        request: (body: {
+            email: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+        verify: (body: {
+            token: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+    };
+    mfa: {
+        challenge: (body: {
+            code: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                status: "authenticated";
+            };
+            error: null;
+        }>;
+        disable: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                status: "disabled";
+            };
+            error: null;
+        }>;
+        setup: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                secret: string;
+                uri: string;
+            };
+            error: null;
+        }>;
+        status: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: import("..").MfaStatus;
+            error: null;
+        }>;
+        verifySetup: (body: {
+            code: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                backupCodes: string[];
+            };
+            error: null;
+        }>;
+    };
+    passkeys: {
+        authenticateOptions: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: PublicKeyCredentialRequestOptionsJSON;
+            error: null;
+        }>;
+        authenticateVerify: (response: unknown) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                status: "authenticated";
+            };
+            error: null;
+        }>;
+        list: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: unknown[];
+            error: null;
+        }>;
+        registerOptions: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: PublicKeyCredentialCreationOptionsJSON;
+            error: null;
+        }>;
+        registerVerify: (response: unknown) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+        remove: (credentialId: string) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+    };
+    passwordless: {
+        requestMagicLink: (body: {
+            email: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+        verifyMagicLink: (body: {
+            token: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                status: "authenticated";
+            };
+            error: null;
+        }>;
+    };
+    passwordReset: {
+        confirm: (body: {
+            password: string;
+            token: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+        request: (body: {
+            email: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+    };
+    sessions: {
+        list: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: unknown[];
+            error: null;
+        }>;
+        revoke: (sessionId: string) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+    };
+    signIn: {
+        email: (body: {
+            email: string;
+            password: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                passwordCompromised?: boolean;
+                status: "authenticated" | "mfa_required";
+            };
+            error: null;
+        }>;
+    };
+    signUp: {
+        email: (body: {
+            email: string;
+            password: string;
+            [extra: string]: unknown;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                status: "authenticated";
+            } | {
+                status: "verification_required";
+            };
+            error: null;
+        }>;
+    };
+    signOut: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: null;
+        error: null;
+    }>;
+    status: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            impersonator?: unknown;
+            user: unknown | null;
+        };
+        error: null;
+    }>;
+};
+export type AuthClient = ReturnType<typeof createAuthClient>;

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export * from './createAuthClient';
+export * from './sessionExpiry';
+export * from '../redirect';
+export { runConditionalAuthentication, runPasskeyRegistration } from './passkeyHelpers';

package/dist/client/passkeyHelpers.d.ts

@@ -0,0 +1,19 @@
+import type { AuthClient, AuthClientError } from './createAuthClient';
+export declare const runConditionalAuthentication: (client: AuthClient) => Promise<{
+    data: null;
+    error: AuthClientError;
+} | {
+    data: {
+        status: "authenticated";
+    };
+    error: null;
+}>;
+export declare const runPasskeyRegistration: (client: AuthClient) => Promise<{
+    data: null;
+    error: AuthClientError;
+} | {
+    data: {
+        ok: true;
+    };
+    error: null;
+}>;

package/dist/client/react.d.ts

@@ -0,0 +1,87 @@
+import type { AuthClient, AuthClientError } from './createAuthClient';
+type Mutator<Args, Data> = (args: Args) => Promise<{
+    data: Data | null;
+    error: AuthClientError | null;
+}>;
+type MutationState<Args, Data> = {
+    data: Data | null;
+    error: AuthClientError | null;
+    isPending: boolean;
+    mutate: Mutator<Args, Data>;
+    reset: () => void;
+};
+export declare const useMagicLink: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useMfaChallenge: (client: AuthClient) => MutationState<{
+    code: string;
+}, {
+    status: "authenticated";
+}>;
+export declare const usePasskeyAutofill: (client: AuthClient) => {
+    cancel: () => void;
+    data: {
+        status: "authenticated";
+    } | null;
+    error: AuthClientError | null;
+    isPending: boolean;
+    start: () => Promise<void>;
+};
+export declare const usePasswordReset: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useSessions: (client: AuthClient) => {
+    data: unknown[] | null;
+    error: AuthClientError | null;
+    isPending: boolean;
+    refetch: () => Promise<void>;
+    revoke: (sessionId: string) => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+};
+export declare const useSignIn: (client: AuthClient) => MutationState<{
+    email: string;
+    password: string;
+}, {
+    passwordCompromised?: boolean;
+    status: "authenticated" | "mfa_required";
+}>;
+export declare const useSignOut: (client: AuthClient) => MutationState<unknown, null>;
+export declare const useSignUp: (client: AuthClient) => MutationState<{
+    [extra: string]: unknown;
+    email: string;
+    password: string;
+}, {
+    status: "authenticated";
+} | {
+    status: "verification_required";
+}>;
+export declare const useUpgradeToPasskey: (client: AuthClient) => {
+    error: AuthClientError | null;
+    isPending: boolean;
+    passkeys: unknown[] | null;
+    refetch: () => Promise<void>;
+    register: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+    shouldPrompt: boolean;
+};
+export { SignIn, type SignInProps } from './components/react/SignIn';
+export { SignUp, type SignUpProps } from './components/react/SignUp';
+export { UserButton, type UserButtonItem, type UserButtonProps, type UserButtonUser } from './components/react/UserButton';

package/dist/client/sessionExpiry.d.ts

@@ -0,0 +1,37 @@
+export type SessionExpiredContext = {
+    returnTo: string;
+    signInUrl: string;
+};
+export type SessionExpiryGuard = {
+    check: () => Promise<boolean>;
+    dispose: () => void;
+};
+export type SessionExpiryGuardConfig = {
+    checkIntervalMs?: number;
+    isProtectedRequest?: (url: URL) => boolean;
+    onExpired?: (context: SessionExpiredContext) => void;
+    protectedPaths?: readonly string[];
+    reason?: string;
+    reasonParam?: string;
+    returnUrlParam?: string;
+    signInPath?: string;
+    statusPath?: string;
+};
+export declare const buildSessionExpiredSignInUrl: ({ currentHref, reason, reasonParam, returnUrlParam, signInPath }: {
+    currentHref: string;
+    reason?: string;
+    reasonParam?: string;
+    returnUrlParam?: string;
+    signInPath?: string;
+}) => string;
+/**
+ * Installs one browser-wide session-expiry guard. It intercepts 401 responses
+ * only for explicitly protected same-origin requests and rechecks the auth
+ * status route when a backgrounded or bfcached page becomes active again.
+ */
+export declare const installSessionExpiryGuard: (config?: SessionExpiryGuardConfig) => SessionExpiryGuard;
+export declare const isProtectedSessionRequest: ({ input, origin, protectedPaths }: {
+    input: RequestInfo | URL;
+    origin: string;
+    protectedPaths: readonly string[];
+}) => boolean;

package/dist/client/solid.d.ts

@@ -0,0 +1,86 @@
+import { type Accessor } from 'solid-js';
+import type { AuthClient, AuthClientError } from './createAuthClient';
+type Mutator<Args, Data> = (args: Args) => Promise<{
+    data: Data | null;
+    error: AuthClientError | null;
+}>;
+type MutationState<Args, Data> = {
+    data: Accessor<Data | null>;
+    error: Accessor<AuthClientError | null>;
+    isPending: Accessor<boolean>;
+    mutate: Mutator<Args, Data>;
+    reset: () => void;
+};
+export declare const useMagicLink: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useMfaChallenge: (client: AuthClient) => MutationState<{
+    code: string;
+}, {
+    status: "authenticated";
+}>;
+export declare const usePasskeyAutofill: (client: AuthClient) => {
+    cancel: () => void;
+    data: Accessor<{
+        status: "authenticated";
+    } | null>;
+    error: Accessor<AuthClientError | null>;
+    isPending: Accessor<boolean>;
+    start: () => Promise<void>;
+};
+export declare const usePasswordReset: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useSessions: (client: AuthClient) => {
+    data: Accessor<unknown[] | null>;
+    error: Accessor<AuthClientError | null>;
+    isPending: Accessor<boolean>;
+    refetch: () => Promise<void>;
+    revoke: (sessionId: string) => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+};
+export declare const useSignIn: (client: AuthClient) => MutationState<{
+    email: string;
+    password: string;
+}, {
+    passwordCompromised?: boolean;
+    status: "authenticated" | "mfa_required";
+}>;
+export declare const useSignOut: (client: AuthClient) => MutationState<unknown, null>;
+export declare const useSignUp: (client: AuthClient) => MutationState<{
+    [extra: string]: unknown;
+    email: string;
+    password: string;
+}, {
+    status: "authenticated";
+} | {
+    status: "verification_required";
+}>;
+export declare const useUpgradeToPasskey: (client: AuthClient) => {
+    error: Accessor<AuthClientError | null>;
+    isPending: Accessor<boolean>;
+    passkeys: Accessor<unknown[] | null>;
+    refetch: () => Promise<void>;
+    register: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+    shouldPrompt: () => boolean;
+};
+export {};

package/dist/client/svelte.d.ts

@@ -0,0 +1,86 @@
+import { type Writable } from 'svelte/store';
+import type { AuthClient, AuthClientError } from './createAuthClient';
+type Mutator<Args, Data> = (args: Args) => Promise<{
+    data: Data | null;
+    error: AuthClientError | null;
+}>;
+type MutationState<Args, Data> = {
+    data: Writable<Data | null>;
+    error: Writable<AuthClientError | null>;
+    isPending: Writable<boolean>;
+    mutate: Mutator<Args, Data>;
+    reset: () => void;
+};
+export declare const useMagicLink: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useMfaChallenge: (client: AuthClient) => MutationState<{
+    code: string;
+}, {
+    status: "authenticated";
+}>;
+export declare const usePasskeyAutofill: (client: AuthClient) => {
+    cancel: () => void;
+    data: Writable<{
+        status: "authenticated";
+    } | null>;
+    error: Writable<AuthClientError | null>;
+    isPending: Writable<boolean>;
+    start: () => Promise<void>;
+};
+export declare const usePasswordReset: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useSessions: (client: AuthClient) => {
+    data: Writable<unknown[] | null>;
+    error: Writable<AuthClientError | null>;
+    isPending: Writable<boolean>;
+    refetch: () => Promise<void>;
+    revoke: (sessionId: string) => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+};
+export declare const useSignIn: (client: AuthClient) => MutationState<{
+    email: string;
+    password: string;
+}, {
+    passwordCompromised?: boolean;
+    status: "authenticated" | "mfa_required";
+}>;
+export declare const useSignOut: (client: AuthClient) => MutationState<unknown, null>;
+export declare const useSignUp: (client: AuthClient) => MutationState<{
+    [extra: string]: unknown;
+    email: string;
+    password: string;
+}, {
+    status: "authenticated";
+} | {
+    status: "verification_required";
+}>;
+export declare const useUpgradeToPasskey: (client: AuthClient) => {
+    error: Writable<AuthClientError | null>;
+    isPending: Writable<boolean>;
+    passkeys: Writable<unknown[] | null>;
+    refetch: () => Promise<void>;
+    register: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+    shouldPrompt: Writable<boolean>;
+};
+export {};

package/dist/client/vue.d.ts

@@ -0,0 +1,88 @@
+import { type Ref } from 'vue';
+import type { AuthClient, AuthClientError } from './createAuthClient';
+type Mutator<Args, Data> = (args: Args) => Promise<{
+    data: Data | null;
+    error: AuthClientError | null;
+}>;
+type MutationState<Args, Data> = {
+    data: Ref<Data | null>;
+    error: Ref<AuthClientError | null>;
+    isPending: Ref<boolean>;
+    mutate: Mutator<Args, Data>;
+    reset: () => void;
+};
+export declare const useMagicLink: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useMfaChallenge: (client: AuthClient) => MutationState<{
+    code: string;
+}, {
+    status: "authenticated";
+}>;
+export declare const usePasskeyAutofill: (client: AuthClient) => {
+    cancel: () => void;
+    data: Ref<{
+        status: "authenticated";
+    } | null, {
+        status: "authenticated";
+    } | null>;
+    error: Ref<AuthClientError | null, AuthClientError | null>;
+    isPending: Ref<boolean, boolean>;
+    start: () => Promise<void>;
+};
+export declare const usePasswordReset: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useSessions: (client: AuthClient) => {
+    data: Ref<unknown[] | null, unknown[] | null>;
+    error: Ref<AuthClientError | null, AuthClientError | null>;
+    isPending: Ref<boolean, boolean>;
+    refetch: () => Promise<void>;
+    revoke: (sessionId: string) => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+};
+export declare const useSignIn: (client: AuthClient) => MutationState<{
+    email: string;
+    password: string;
+}, {
+    passwordCompromised?: boolean;
+    status: "authenticated" | "mfa_required";
+}>;
+export declare const useSignOut: (client: AuthClient) => MutationState<unknown, null>;
+export declare const useSignUp: (client: AuthClient) => MutationState<{
+    [extra: string]: unknown;
+    email: string;
+    password: string;
+}, {
+    status: "authenticated";
+} | {
+    status: "verification_required";
+}>;
+export declare const useUpgradeToPasskey: (client: AuthClient) => {
+    error: Ref<AuthClientError | null, AuthClientError | null>;
+    isPending: Ref<boolean, boolean>;
+    passkeys: Ref<unknown[] | null, unknown[] | null>;
+    refetch: () => Promise<void>;
+    register: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+    shouldPrompt: Ref<boolean, boolean>;
+};
+export {};

package/dist/compliance/cipher.d.ts

@@ -0,0 +1,11 @@
+export type SecretCipher = {
+    decrypt: (ciphertext: string) => Promise<string>;
+    encrypt: (plaintext: string) => Promise<string>;
+    needsReencryption?: (ciphertext: string) => boolean;
+};
+export declare const createSecretCipher: (keyMaterial: string) => SecretCipher;
+export declare const createVersionedSecretCipher: ({ currentVersion, keys, legacyKey }: {
+    currentVersion: number;
+    keys: Readonly<Record<number, string>>;
+    legacyKey?: string;
+}) => SecretCipher;