@xylex-group/athena 2.12.0 → 2.13.0

package/dist/utils.cjs

@@ -70,6 +70,13 @@ function readTrimmedString(value) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : null;
 }
+function asNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
 function asNumber(value) {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value === "string" && value.trim().length > 0) {
@@ -96,6 +103,46 @@ function parseBooleanFlag(rawValue, fallback) {
   return fallback;
 }
 
+// src/utils/require-env.ts
+function requireEnv(names, env) {
+  if (!names.length) {
+    throw new Error(
+      "requireEnv() requires at least one environment variable name."
+    );
+  }
+  const source = env ?? readProcessEnv();
+  for (const name of names) {
+    const value = source[name]?.trim();
+    if (value) {
+      return value;
+    }
+  }
+  throw new Error(
+    `Missing required environment variable. Expected one of: ${names.join(", ")}`
+  );
+}
+function readEnv(names, env) {
+  if (!names.length) {
+    return void 0;
+  }
+  const source = env ?? readProcessEnv();
+  for (const name of names) {
+    const value = source[name]?.trim();
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function readProcessEnv() {
+  try {
+    const processEnv = globalThis.process?.env;
+    return processEnv ?? {};
+  } catch {
+    return {};
+  }
+}
+
 // src/utils/hostname.ts
 var LOCAL_IPV4_PATTERN = /^127(?:\.\d{1,3}){3}$/;
 function isLocalHostname(hostname) {
@@ -112,13 +159,41 @@ function isLocalHostname(hostname) {
   return false;
 }
 
+// src/utils/request-origin.ts
+function isDynamicServerUsageError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  if (err.digest === "DYNAMIC_SERVER_USAGE") {
+    return true;
+  }
+  return typeof err.message === "string" && err.message.includes("Dynamic server usage:");
+}
+function getOriginFromHeaders(headersList, options = {}) {
+  const origin = headersList.get("origin")?.trim();
+  if (origin) {
+    return origin;
+  }
+  const hostRaw = headersList.get("x-forwarded-host") ?? headersList.get("host");
+  const host = hostRaw?.split(",")[0]?.trim();
+  if (!host) {
+    return null;
+  }
+  const protoRaw = headersList.get("x-forwarded-proto");
+  const protoFirst = protoRaw?.split(",")[0]?.trim().toLowerCase();
+  const proto = protoFirst === "http" || protoFirst === "https" ? protoFirst : options.preferHttpWhenMissingProto ? "http" : "https";
+  return `${proto}://${host}`;
+}
+
 // src/utils/auth-cookies.ts
-var DEFAULT_AUTH_COOKIE_PREFIXES = [
+var ATHENA_AUTH_COOKIE_PREFIXES = [
   "athena-auth",
   "__Secure-athena-auth",
   "better-auth",
   "__Secure-better-auth"
 ];
+var DEFAULT_AUTH_COOKIE_PREFIXES = ATHENA_AUTH_COOKIE_PREFIXES;
 function extractCookieNames(cookieHeader) {
   const names = /* @__PURE__ */ new Set();
   for (const rawCookie of cookieHeader.split(";")) {
@@ -180,9 +255,11 @@ function clearAuthCookies(options = {}) {
   if (!cookieHeader?.trim()) {
     return [];
   }
-  const prefixes = options.prefixes?.length ? options.prefixes : [...DEFAULT_AUTH_COOKIE_PREFIXES];
+  const prefixes = options.prefixes?.length ? options.prefixes : [...ATHENA_AUTH_COOKIE_PREFIXES];
   const cookieNames = extractCookieNames(cookieHeader);
-  const namesToClear = cookieNames.filter((name) => prefixes.some((prefix) => name.startsWith(prefix)));
+  const namesToClear = cookieNames.filter(
+    (name) => prefixes.some((prefix) => name.startsWith(prefix))
+  );
   if (namesToClear.length === 0) {
     return [];
   }
@@ -198,6 +275,295 @@ function clearAuthCookies(options = {}) {
   return namesToClear;
 }
 
+// src/cookies/session-cookie-detection.ts
+var SESSION_COOKIE_PATTERNS = [
+  /(?:^|;\s*)(?:__Secure-)?better-auth\.session_token=/,
+  /(?:^|;\s*)(?:__Secure-)?better-auth-session_token=/,
+  /(?:^|;\s*)(?:__Secure-)?athena-auth\.session-token=/,
+  /(?:^|;\s*)(?:__Secure-)?athena-auth-session-token=/,
+  /(?:^|;\s*)(?:__Secure-)?athena-auth\.session_token=/,
+  /(?:^|;\s*)(?:__Secure-)?athena-auth-session_token=/
+];
+function hasAuthSessionCookie(cookieHeader) {
+  if (!cookieHeader) {
+    return false;
+  }
+  return SESSION_COOKIE_PATTERNS.some((pattern) => pattern.test(cookieHeader));
+}
+
+// src/utils/athena-auth-url.ts
+var ATHENA_AUTH_PATH = "/api/auth";
+var LOCAL_DEV_ORIGIN = "http://localhost:3000";
+var DEFAULT_ATHENA_AUTH_ORIGIN = "https://auth.athena-auth.com";
+var DEFAULT_ATHENA_AUTH_UPSTREAM_URL = DEFAULT_ATHENA_AUTH_ORIGIN;
+var ATHENA_AUTH_UPSTREAM_ENV_KEYS = [
+  "ATHENA_AUTH_UPSTREAM_URL",
+  "ATHENA_AUTH_URL",
+  "NEXT_PUBLIC_ATHENA_AUTH_UPSTREAM_URL",
+  "NEXT_PUBLIC_ATHENA_AUTH_URL"
+];
+var ATHENA_AUTH_UPSTREAM_URL_ENV_NAMES = ATHENA_AUTH_UPSTREAM_ENV_KEYS;
+var LEADING_SLASHES_REGEX = /^\/+/;
+function stripTrailingSlashes(value) {
+  return value.replace(/\/+$/g, "");
+}
+function ensureLeadingSlash(value) {
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function ensureAthenaAuthPath(pathname) {
+  const normalizedPath = stripTrailingSlashes(
+    ensureLeadingSlash(pathname.trim())
+  );
+  if (!normalizedPath || normalizedPath === "/") {
+    return ATHENA_AUTH_PATH;
+  }
+  if (normalizedPath.endsWith(ATHENA_AUTH_PATH)) {
+    return normalizedPath;
+  }
+  return `${normalizedPath}${ATHENA_AUTH_PATH}`;
+}
+function stripAthenaAuthPath(pathname) {
+  const normalizedPath = stripTrailingSlashes(
+    ensureLeadingSlash(pathname.trim())
+  );
+  if (!normalizedPath || normalizedPath === "/") {
+    return "/";
+  }
+  if (normalizedPath === ATHENA_AUTH_PATH) {
+    return "/";
+  }
+  if (normalizedPath.endsWith(ATHENA_AUTH_PATH)) {
+    const withoutAuthPath = normalizedPath.slice(0, -ATHENA_AUTH_PATH.length);
+    return withoutAuthPath ? ensureLeadingSlash(withoutAuthPath) : "/";
+  }
+  return normalizedPath;
+}
+function readProcessEnv2() {
+  try {
+    const maybeProcess = globalThis.process;
+    return maybeProcess?.env;
+  } catch {
+    return void 0;
+  }
+}
+function getBrowserOrigin() {
+  try {
+    const origin = globalThis.window?.location?.origin;
+    return typeof origin === "string" && origin.length > 0 ? origin : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isAbsoluteUrl(value) {
+  const trimmed = value.trim();
+  return trimmed.startsWith("http://") || trimmed.startsWith("https://");
+}
+function readAthenaAuthUpstreamUrlFromEnv(env) {
+  for (const key of ATHENA_AUTH_UPSTREAM_ENV_KEYS) {
+    const value = env[key]?.trim();
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function resolveConfiguredAthenaAuthUpstreamUrl(rawUpstreamUrl) {
+  if (typeof rawUpstreamUrl === "string") {
+    const trimmed = rawUpstreamUrl.trim();
+    return trimmed || void 0;
+  }
+  if (rawUpstreamUrl) {
+    return readAthenaAuthUpstreamUrlFromEnv(rawUpstreamUrl);
+  }
+  const processEnv = readProcessEnv2();
+  return processEnv ? readAthenaAuthUpstreamUrlFromEnv(processEnv) : void 0;
+}
+function normalizeAthenaAuthBaseUrl(urlOrPath) {
+  const trimmed = urlOrPath.trim();
+  if (!trimmed) {
+    return ATHENA_AUTH_PATH;
+  }
+  if (isAbsoluteUrl(trimmed)) {
+    const url = new URL(trimmed);
+    url.pathname = ensureAthenaAuthPath(url.pathname);
+    url.search = "";
+    url.hash = "";
+    return stripTrailingSlashes(url.toString());
+  }
+  return ensureAthenaAuthPath(trimmed);
+}
+function resolveAthenaAuthUpstreamUrl(rawUpstreamUrl) {
+  const configuredUpstream = resolveConfiguredAthenaAuthUpstreamUrl(rawUpstreamUrl) || DEFAULT_ATHENA_AUTH_ORIGIN;
+  if (isAbsoluteUrl(configuredUpstream)) {
+    const upstreamUrl = new URL(configuredUpstream);
+    upstreamUrl.pathname = stripAthenaAuthPath(upstreamUrl.pathname);
+    upstreamUrl.search = "";
+    upstreamUrl.hash = "";
+    return stripTrailingSlashes(upstreamUrl.toString());
+  }
+  const normalizedPath = stripAthenaAuthPath(configuredUpstream);
+  return stripTrailingSlashes(
+    new URL(normalizedPath, LOCAL_DEV_ORIGIN).toString()
+  );
+}
+function resolveBrowserFacingOrigin(rawUpstreamUrl) {
+  if (resolveConfiguredAthenaAuthUpstreamUrl(rawUpstreamUrl)) {
+    return `${resolveAthenaAuthUpstreamUrl(rawUpstreamUrl)}/`;
+  }
+  const browserOrigin = getBrowserOrigin();
+  if (browserOrigin) {
+    return `${browserOrigin}/`;
+  }
+  return `${LOCAL_DEV_ORIGIN}/`;
+}
+function resolvePreservedAthenaAuthBaseUrl(configuredAuthBaseUrl, rawUpstreamUrl) {
+  const trimmed = configuredAuthBaseUrl.trim();
+  const preservedConfiguredBaseUrl = trimmed || ATHENA_AUTH_PATH;
+  if (isAbsoluteUrl(preservedConfiguredBaseUrl)) {
+    return stripTrailingSlashes(preservedConfiguredBaseUrl);
+  }
+  return stripTrailingSlashes(
+    new URL(
+      ensureLeadingSlash(preservedConfiguredBaseUrl),
+      resolveBrowserFacingOrigin(rawUpstreamUrl)
+    ).toString()
+  );
+}
+function resolveAthenaAuthClientBaseUrl(configuredAuthBaseUrl, rawUpstreamUrl, options = {}) {
+  let baseInput;
+  if (typeof configuredAuthBaseUrl === "string") {
+    baseInput = configuredAuthBaseUrl;
+  } else if (configuredAuthBaseUrl) {
+    baseInput = readAthenaAuthUpstreamUrlFromEnv(configuredAuthBaseUrl) ?? ATHENA_AUTH_PATH;
+  } else {
+    const fromEnv = resolveConfiguredAthenaAuthUpstreamUrl(rawUpstreamUrl);
+    baseInput = fromEnv ?? ATHENA_AUTH_PATH;
+  }
+  if (options.appendAuthPath === false) {
+    return resolvePreservedAthenaAuthBaseUrl(baseInput, rawUpstreamUrl);
+  }
+  const normalizedConfiguredBaseUrl = normalizeAthenaAuthBaseUrl(baseInput);
+  if (isAbsoluteUrl(normalizedConfiguredBaseUrl)) {
+    return normalizedConfiguredBaseUrl;
+  }
+  const browserOrigin = getBrowserOrigin();
+  if (browserOrigin) {
+    return stripTrailingSlashes(
+      new URL(normalizedConfiguredBaseUrl, browserOrigin).toString()
+    );
+  }
+  if (resolveConfiguredAthenaAuthUpstreamUrl(rawUpstreamUrl)) {
+    const upstream = resolveAthenaAuthUpstreamUrl(rawUpstreamUrl);
+    return stripTrailingSlashes(
+      new URL(ATHENA_AUTH_PATH, `${upstream}/`).toString()
+    );
+  }
+  return stripTrailingSlashes(
+    new URL(normalizedConfiguredBaseUrl, LOCAL_DEV_ORIGIN).toString()
+  );
+}
+function resolveAthenaAuthRequestUrl(path, rawBaseUrl) {
+  const normalizedPath = path.replace(LEADING_SLASHES_REGEX, "");
+  const base = resolveAthenaAuthClientBaseUrl(rawBaseUrl);
+  return new URL(normalizedPath, `${base}/`).toString();
+}
+var ATHENA_AUTH_VERIFY_EMAIL_PATH = "verify-email";
+var ATHENA_AUTH_GET_SESSION_PATH = "get-session";
+var ATHENA_AUTH_GET_SESSION_ABSOLUTE_PATH = `${ATHENA_AUTH_PATH}/get-session`;
+var AUTH_SESSION_PATH = ATHENA_AUTH_GET_SESSION_ABSOLUTE_PATH;
+var ATHENA_AUTH_DISABLE_COOKIE_CACHE_QUERY_PARAM = "disableCookieCache";
+var DISABLE_COOKIE_CACHE_QUERY_PARAM = ATHENA_AUTH_DISABLE_COOKIE_CACHE_QUERY_PARAM;
+var ATHENA_AUTH_DISABLE_COOKIE_CACHE_QUERY_VALUE = "true";
+var DISABLE_COOKIE_CACHE_QUERY_VALUE = ATHENA_AUTH_DISABLE_COOKIE_CACHE_QUERY_VALUE;
+var ATHENA_SESSION_DATA_HEADER = "x-session-data";
+var SESSION_DATA_HEADER = ATHENA_SESSION_DATA_HEADER;
+function resolveEmailVerificationCallbackUrl(rawBaseUrl) {
+  return resolveAthenaAuthRequestUrl(ATHENA_AUTH_VERIFY_EMAIL_PATH, rawBaseUrl);
+}
+function createFreshSessionLookupUrl(baseUrl) {
+  const url = new URL(ATHENA_AUTH_GET_SESSION_ABSOLUTE_PATH, baseUrl);
+  url.searchParams.set(
+    ATHENA_AUTH_DISABLE_COOKIE_CACHE_QUERY_PARAM,
+    ATHENA_AUTH_DISABLE_COOKIE_CACHE_QUERY_VALUE
+  );
+  return url;
+}
+
+// src/utils/auth-routes.ts
+var AUTH_DEFAULT_VIEW = "sign-in";
+var AUTH_TWO_FACTOR_SEGMENT = "two-factor";
+var AUTH_VIEW_BY_SEGMENT = {
+  "accept-invitation": "accept-invitation",
+  "check-email": "check-email",
+  "forget-password": "forgot-password",
+  "forgot-password": "forgot-password",
+  logout: "logout",
+  "reset-email-sent": "reset-email-sent",
+  "reset-password": "reset-password",
+  "sign-in": "sign-in",
+  "sign-up": "sign-up"
+};
+var AUTHENTICATED_REDIRECT_VIEW_SET = /* @__PURE__ */ new Set([
+  "sign-in",
+  "sign-up",
+  "forgot-password"
+]);
+function resolveAuthViewFromSegment(segment) {
+  if (!segment) {
+    return AUTH_DEFAULT_VIEW;
+  }
+  return AUTH_VIEW_BY_SEGMENT[segment] ?? null;
+}
+function shouldRedirectAuthenticatedAuthView(view) {
+  return AUTHENTICATED_REDIRECT_VIEW_SET.has(view);
+}
+var AUTH_ROUTES = {
+  acceptInvitation: "/auth/accept-invitation",
+  appHome: "/",
+  checkEmail: "/auth/check-email",
+  forgotPassword: "/auth/forgot-password",
+  logout: "/auth/logout",
+  resetEmailSent: "/auth/reset-email-sent",
+  resetPassword: "/auth/reset-password",
+  signIn: "/auth/sign-in",
+  signUp: "/auth/sign-up",
+  socialCallback: "/auth/social-callback"
+};
+function createAuthRoutes(overrides = {}) {
+  return {
+    ...AUTH_ROUTES,
+    ...overrides
+  };
+}
+function createAuthModeRedirects(routes = AUTH_ROUTES) {
+  return {
+    "forgot-password": routes.forgotPassword,
+    login: routes.signIn,
+    logout: routes.logout,
+    "reset-password": routes.resetPassword,
+    signup: routes.signUp
+  };
+}
+var AUTH_MODE_REDIRECTS = createAuthModeRedirects();
+var AUTH_MODE_SET = new Set(Object.keys(AUTH_MODE_REDIRECTS));
+var AUTHENTICATED_REDIRECT_MODE_SET = /* @__PURE__ */ new Set([
+  "login",
+  "signup",
+  "forgot-password"
+]);
+function isAuthMode(value) {
+  return AUTH_MODE_SET.has(value);
+}
+function shouldRedirectAuthenticatedAuthMode(mode) {
+  return AUTHENTICATED_REDIRECT_MODE_SET.has(mode);
+}
+function resolveAuthModeRedirect(mode, redirects = AUTH_MODE_REDIRECTS) {
+  if (!mode || !isAuthMode(mode)) {
+    return null;
+  }
+  return redirects[mode];
+}
+
 // src/utils/proxy-request-headers.ts
 function proxyRequestHeaders(request) {
   const headers = new Headers(request.headers);
@@ -251,7 +617,7 @@ var getSessionCookie = (request, config) => {
 
 // src/utils/athena-request-headers.ts
 var NO_CACHE_HEADER_VALUE = "no-cache";
-var API_KEY_HEADER_CANDIDATES = ["x-api-key", "apikey"];
+var API_KEY_HEADER_CANDIDATES = ["X-Athena-Key", "x-athena-key", "X-Api-Key", "x-api-key", "apikey"];
 var ATHENA_KEY_HEADER_CANDIDATES = ["X-Athena-Key", "x-athena-key"];
 var SESSION_TOKEN_HEADER_CANDIDATES = ["X-Athena-Auth-Session-Token"];
 var BEARER_MIRROR_HEADER_CANDIDATES = ["X-Athena-Auth-Bearer-Token"];
@@ -353,14 +719,6 @@ function buildServiceRequestHeaders(profile, sdkHeaderValue, config, options, ex
   });
 }
 function applyAthenaApiKeyHeaders(headers, apiKey, athenaKey) {
-  if (apiKey) {
-    if (!hasHeaderIgnoreCase(headers, "apikey")) {
-      headers.apikey = apiKey;
-    }
-    if (!hasHeaderIgnoreCase(headers, "x-api-key")) {
-      headers["x-api-key"] = apiKey;
-    }
-  }
   const resolvedAthenaKey = normalizeHeaderValue(athenaKey) ?? normalizeHeaderValue(apiKey);
   if (resolvedAthenaKey && !hasHeaderIgnoreCase(headers, "X-Athena-Key")) {
     headers["X-Athena-Key"] = resolvedAthenaKey;
@@ -420,6 +778,25 @@ function applyAthenaPgUriHeaders(headers, input) {
     }
   }
 }
+function buildAthenaGatewayHeaders(input) {
+  const trimmedClientName = input.clientName?.trim();
+  const trimmedGatewayKey = input.gatewayKey?.trim();
+  const merged = {
+    ...trimmedClientName ? {
+      "X-Athena-Client": trimmedClientName
+    } : {},
+    ...trimmedGatewayKey ? {
+      "X-Api-Key": trimmedGatewayKey,
+      "X-Athena-Key": trimmedGatewayKey
+    } : {},
+    ...input.headers
+  };
+  return Object.fromEntries(
+    Object.entries(merged).flatMap(
+      ([key, value]) => typeof value === "string" && value.trim() ? [[key, value.trim()]] : []
+    )
+  );
+}
 function buildAthenaRequestHeaders(input) {
   const forceNoCache = Boolean(input.forceNoCache);
   const mergedExtraHeaders = mergeExtraHeaders(input.configHeaders, input.callHeaders);
@@ -527,29 +904,78 @@ function sqlBigInt(value) {
   return `${BigInt(value).toString()}::bigint`;
 }
 
+exports.ATHENA_AUTH_COOKIE_PREFIXES = ATHENA_AUTH_COOKIE_PREFIXES;
+exports.ATHENA_AUTH_DISABLE_COOKIE_CACHE_QUERY_PARAM = ATHENA_AUTH_DISABLE_COOKIE_CACHE_QUERY_PARAM;
+exports.ATHENA_AUTH_DISABLE_COOKIE_CACHE_QUERY_VALUE = ATHENA_AUTH_DISABLE_COOKIE_CACHE_QUERY_VALUE;
+exports.ATHENA_AUTH_GET_SESSION_ABSOLUTE_PATH = ATHENA_AUTH_GET_SESSION_ABSOLUTE_PATH;
+exports.ATHENA_AUTH_GET_SESSION_PATH = ATHENA_AUTH_GET_SESSION_PATH;
+exports.ATHENA_AUTH_PATH = ATHENA_AUTH_PATH;
+exports.ATHENA_AUTH_UPSTREAM_ENV_KEYS = ATHENA_AUTH_UPSTREAM_ENV_KEYS;
+exports.ATHENA_AUTH_UPSTREAM_URL_ENV_NAMES = ATHENA_AUTH_UPSTREAM_URL_ENV_NAMES;
+exports.ATHENA_AUTH_VERIFY_EMAIL_PATH = ATHENA_AUTH_VERIFY_EMAIL_PATH;
+exports.ATHENA_SESSION_DATA_HEADER = ATHENA_SESSION_DATA_HEADER;
+exports.AUTHENTICATED_REDIRECT_MODE_SET = AUTHENTICATED_REDIRECT_MODE_SET;
+exports.AUTHENTICATED_REDIRECT_VIEW_SET = AUTHENTICATED_REDIRECT_VIEW_SET;
+exports.AUTH_DEFAULT_VIEW = AUTH_DEFAULT_VIEW;
+exports.AUTH_MODE_REDIRECTS = AUTH_MODE_REDIRECTS;
+exports.AUTH_MODE_SET = AUTH_MODE_SET;
+exports.AUTH_ROUTES = AUTH_ROUTES;
+exports.AUTH_SESSION_PATH = AUTH_SESSION_PATH;
+exports.AUTH_TWO_FACTOR_SEGMENT = AUTH_TWO_FACTOR_SEGMENT;
+exports.AUTH_VIEW_BY_SEGMENT = AUTH_VIEW_BY_SEGMENT;
+exports.DEFAULT_ATHENA_AUTH_ORIGIN = DEFAULT_ATHENA_AUTH_ORIGIN;
+exports.DEFAULT_ATHENA_AUTH_UPSTREAM_URL = DEFAULT_ATHENA_AUTH_UPSTREAM_URL;
+exports.DEFAULT_AUTH_COOKIE_PREFIXES = DEFAULT_AUTH_COOKIE_PREFIXES;
+exports.DISABLE_COOKIE_CACHE_QUERY_PARAM = DISABLE_COOKIE_CACHE_QUERY_PARAM;
+exports.DISABLE_COOKIE_CACHE_QUERY_VALUE = DISABLE_COOKIE_CACHE_QUERY_VALUE;
+exports.LOCAL_DEV_ORIGIN = LOCAL_DEV_ORIGIN;
+exports.SESSION_COOKIE_PATTERNS = SESSION_COOKIE_PATTERNS;
+exports.SESSION_DATA_HEADER = SESSION_DATA_HEADER;
 exports.applyAthenaApiKeyHeaders = applyAthenaApiKeyHeaders;
 exports.applyAthenaAuthContextHeaders = applyAthenaAuthContextHeaders;
 exports.applyAthenaPgUriHeaders = applyAthenaPgUriHeaders;
 exports.asBoolean = asBoolean;
 exports.asBooleanOrNull = asBooleanOrNull;
 exports.asIdentifier = asIdentifier;
+exports.asNonEmptyString = asNonEmptyString;
 exports.asNumber = asNumber;
 exports.asRecord = asRecord;
 exports.asString = asString;
 exports.asStringArray = asStringArray;
+exports.buildAthenaGatewayHeaders = buildAthenaGatewayHeaders;
 exports.buildAthenaRequestHeaders = buildAthenaRequestHeaders;
 exports.buildServiceRequestHeaders = buildServiceRequestHeaders;
 exports.clearAuthCookies = clearAuthCookies;
+exports.createAuthModeRedirects = createAuthModeRedirects;
+exports.createAuthRoutes = createAuthRoutes;
+exports.createFreshSessionLookupUrl = createFreshSessionLookupUrl;
 exports.escapeLikePatternValue = escapeLikePatternValue;
 exports.firstString = firstString;
+exports.getOriginFromHeaders = getOriginFromHeaders;
+exports.hasAuthSessionCookie = hasAuthSessionCookie;
 exports.hasHeaderIgnoreCase = hasHeaderIgnoreCase;
+exports.isAbsoluteUrl = isAbsoluteUrl;
+exports.isAuthMode = isAuthMode;
+exports.isDynamicServerUsageError = isDynamicServerUsageError;
 exports.isLocalHostname = isLocalHostname;
+exports.normalizeAthenaAuthBaseUrl = normalizeAthenaAuthBaseUrl;
 exports.parseBooleanFlag = parseBooleanFlag;
 exports.proxyRequestHeaders = proxyRequestHeaders;
 exports.quoteSqlStringLiteral = quoteSqlStringLiteral;
+exports.readAthenaAuthUpstreamUrlFromEnv = readAthenaAuthUpstreamUrlFromEnv;
+exports.readEnv = readEnv;
 exports.readTrimmedString = readTrimmedString;
+exports.requireEnv = requireEnv;
+exports.resolveAthenaAuthClientBaseUrl = resolveAthenaAuthClientBaseUrl;
+exports.resolveAthenaAuthRequestUrl = resolveAthenaAuthRequestUrl;
+exports.resolveAthenaAuthUpstreamUrl = resolveAthenaAuthUpstreamUrl;
+exports.resolveAuthModeRedirect = resolveAuthModeRedirect;
+exports.resolveAuthViewFromSegment = resolveAuthViewFromSegment;
+exports.resolveEmailVerificationCallbackUrl = resolveEmailVerificationCallbackUrl;
 exports.resolveHeaderValue = resolveHeaderValue;
 exports.resolveRequestHeaderOverrides = resolveRequestHeaderOverrides;
+exports.shouldRedirectAuthenticatedAuthMode = shouldRedirectAuthenticatedAuthMode;
+exports.shouldRedirectAuthenticatedAuthView = shouldRedirectAuthenticatedAuthView;
 exports.slugify = slugify;
 exports.sqlBigInt = sqlBigInt;
 exports.sqlJsonbLiteral = sqlJsonbLiteral;