@xylex-group/athena 2.4.1 → 2.6.0

package/dist/index-CVcQCGyG.d.ts

@@ -0,0 +1,174 @@
+type AthenaCookieSameSite = 'strict' | 'lax' | 'none';
+interface AthenaCookieOptions {
+    maxAge?: number;
+    expires?: Date;
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    partitioned?: boolean;
+    sameSite?: AthenaCookieSameSite;
+    [key: string]: unknown;
+}
+interface AthenaAuthCookie {
+    name: string;
+    attributes: AthenaCookieOptions;
+}
+interface AthenaAuthCookies {
+    sessionToken: AthenaAuthCookie;
+    sessionData: AthenaAuthCookie;
+    dontRememberToken: AthenaAuthCookie;
+    accountData: AthenaAuthCookie;
+}
+interface AthenaCookieDefinition {
+    name?: string;
+    attributes?: AthenaCookieOptions;
+}
+type AthenaCookieVersionResolver = string | ((session: Record<string, unknown>, user: Record<string, unknown>) => string | Promise<string>);
+interface AthenaSessionCookieCacheConfig {
+    enabled?: boolean;
+    maxAge?: number;
+    strategy?: 'compact' | 'jwt' | 'jwe';
+    version?: AthenaCookieVersionResolver;
+}
+interface AthenaCookieAdvancedOptions {
+    cookiePrefix?: string;
+    useSecureCookies?: boolean;
+    defaultCookieAttributes?: AthenaCookieOptions;
+    cookies?: Record<string, AthenaCookieDefinition>;
+    crossSubDomainCookies?: {
+        enabled?: boolean;
+        domain?: string;
+    };
+}
+interface AthenaCookiesOptions {
+    baseURL?: string | {
+        protocol?: 'http' | 'https' | 'auto';
+        allowedHosts?: string[];
+    };
+    session?: {
+        expiresIn?: number;
+        cookieCache?: AthenaSessionCookieCacheConfig;
+    };
+    advanced?: AthenaCookieAdvancedOptions;
+}
+interface AthenaSessionPair<SessionShape extends Record<string, unknown> = Record<string, unknown>, UserShape extends Record<string, unknown> = Record<string, unknown>> {
+    session: SessionShape & {
+        token: string;
+    };
+    user: UserShape;
+}
+interface AthenaCookieContextRuntime {
+    headers?: Headers;
+    getCookie?: (name: string) => string | null | undefined;
+    setCookie: (name: string, value: string, attributes: AthenaCookieOptions) => void;
+    logger?: {
+        debug?: (event: string, payload?: unknown) => void;
+    };
+    setSignedCookie?: (name: string, value: string, secret: string, attributes: AthenaCookieOptions) => void | Promise<void>;
+    getSignedCookie?: (name: string, secret: string) => string | null | Promise<string | null>;
+    context: {
+        secret?: string;
+        authCookies: AthenaAuthCookies;
+        sessionConfig?: {
+            expiresIn?: number;
+        };
+        options?: {
+            session?: {
+                cookieCache?: AthenaSessionCookieCacheConfig;
+            };
+            account?: {
+                storeAccountCookie?: boolean;
+            };
+        };
+        setNewSession?: (session: AthenaSessionPair) => void;
+    };
+}
+interface AthenaGetCookieCacheConfig<SessionShape extends Record<string, unknown> = Record<string, unknown>, UserShape extends Record<string, unknown> = Record<string, unknown>> {
+    cookiePrefix?: string;
+    cookieName?: string;
+    isSecure?: boolean;
+    secret?: string;
+    strategy?: 'compact' | 'jwt' | 'jwe';
+    version?: string | ((session: SessionShape, user: UserShape) => string | Promise<string>);
+}
+
+interface CookieAttributes {
+    value: string;
+    'max-age'?: number;
+    expires?: Date;
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    httponly?: boolean;
+    partitioned?: boolean;
+    samesite?: 'strict' | 'lax' | 'none';
+    [key: string]: unknown;
+}
+declare const SECURE_COOKIE_PREFIX = "__Secure-";
+declare const HOST_COOKIE_PREFIX = "__Host-";
+/**
+ * Remove __Secure- or __Host- prefix from cookie name.
+ */
+declare function stripSecureCookiePrefix(cookieName: string): string;
+/**
+ * Split a comma-joined `Set-Cookie` header string into individual cookies.
+ */
+declare function splitSetCookieHeader(setCookie: string): string[];
+declare function parseSetCookieHeader(setCookie: string): Map<string, CookieAttributes>;
+declare function toCookieOptions(attributes: CookieAttributes): AthenaCookieOptions;
+/**
+ * Parse a `Cookie` header into a key/value map.
+ */
+declare function parseCookies(cookieHeader: string): Map<string, string>;
+/**
+ * Add or replace a cookie in the request `Cookie` header.
+ */
+declare function setRequestCookie(headers: Headers, name: string, value: string): void;
+declare function setCookieToHeader(headers: Headers): (context: {
+    response: Response;
+}) => void;
+
+interface StoreCookie {
+    name: string;
+    value: string;
+    attributes: AthenaCookieOptions;
+}
+declare const createSessionStore: (cookieName: string, cookieOptions: AthenaCookieOptions, ctx: AthenaCookieContextRuntime) => {
+    getValue(): string;
+    hasChunks(): boolean;
+    chunk(value: string, options?: Partial<AthenaCookieOptions>): StoreCookie[];
+    clean(): StoreCookie[];
+    setCookies(cookies: StoreCookie[]): void;
+};
+declare function getChunkedCookie(ctx: AthenaCookieContextRuntime, cookieName: string): string | null;
+/**
+ * SDK helper to read an account cookie value.
+ * - If plain JSON: returns parsed value.
+ * - If base64url-encoded JSON: returns parsed value.
+ * - Otherwise: returns the raw cookie string.
+ */
+declare function getAccountCookie(ctx: AthenaCookieContextRuntime, cookieName?: string): Promise<unknown | null>;
+
+declare function createCookieGetter(options: AthenaCookiesOptions): (cookieName: string, overrideAttributes?: Partial<AthenaCookieOptions>) => AthenaAuthCookie;
+declare function getCookies(options: AthenaCookiesOptions): AthenaAuthCookies;
+declare function setCookieCache(ctx: AthenaCookieContextRuntime, session: AthenaSessionPair, dontRememberMe: boolean): Promise<void>;
+declare function setSessionCookie(ctx: AthenaCookieContextRuntime, session: AthenaSessionPair, dontRememberMe?: boolean, overrides?: Partial<AthenaCookieOptions>): Promise<void>;
+/**
+ * Expires a cookie by setting `maxAge: 0` while preserving attributes.
+ */
+declare function expireCookie(ctx: AthenaCookieContextRuntime, cookie: AthenaAuthCookie): void;
+declare function deleteSessionCookie(ctx: AthenaCookieContextRuntime, skipDontRememberMe?: boolean): void;
+declare const getSessionCookie: (request: Request | Headers, config?: {
+    cookiePrefix?: string;
+    cookieName?: string;
+    path?: string;
+} | undefined) => string | null;
+declare const getCookieCache: <SessionShape extends Record<string, unknown> = Record<string, unknown>, UserShape extends Record<string, unknown> = Record<string, unknown>>(request: Request | Headers, config?: AthenaGetCookieCacheConfig<SessionShape, UserShape>) => Promise<{
+    session: SessionShape;
+    user: UserShape;
+    updatedAt: number;
+    version?: string;
+} | null>;
+
+export { type AthenaCookiesOptions as A, HOST_COOKIE_PREFIX as H, SECURE_COOKIE_PREFIX as S, type AthenaSessionPair as a, type AthenaCookieOptions as b, type AthenaAuthCookies as c, getSessionCookie as d, type AthenaCookieContextRuntime as e, type AthenaAuthCookie as f, getCookieCache as g, type AthenaGetCookieCacheConfig as h, createCookieGetter as i, createSessionStore as j, deleteSessionCookie as k, expireCookie as l, getAccountCookie as m, getChunkedCookie as n, getCookies as o, parseCookies as p, parseSetCookieHeader as q, setCookieToHeader as r, setCookieCache as s, setRequestCookie as t, setSessionCookie as u, splitSetCookieHeader as v, stripSecureCookiePrefix as w, toCookieOptions as x };