@xylex-group/athena 2.12.0 → 2.13.0

package/dist/next/server.cjs

@@ -138,6 +138,22 @@ function parseCookies(cookieHeader) {
   });
   return cookieMap;
 }
+
+// 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));
+}
 var getSessionCookie = (request2, config) => {
   const cookies = (request2 instanceof Headers || !("headers" in request2) ? request2 : request2.headers).get("cookie");
   if (!cookies) {
@@ -162,7 +178,7 @@ var getSessionCookie = (request2, 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"];
@@ -264,14 +280,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;
@@ -397,7 +405,7 @@ function buildAthenaRequestHeaders(input) {
 
 // package.json
 var package_default = {
-  version: "2.12.0"
+  version: "2.13.0"
 };
 
 // src/sdk-version.ts
@@ -2826,38 +2834,6 @@ async function withRetry(config, fn) {
   throw new Error("withRetry reached an unexpected state");
 }
 
-// src/db/module.ts
-function createDbModule(input) {
-  const db = {
-    from: input.from,
-    select(table, first, second) {
-      if (first && typeof first === "object" && !Array.isArray(first)) {
-        return input.from(table).select(void 0, first);
-      }
-      return input.from(table).select(first, second);
-    },
-    insert(table, values, options) {
-      return Array.isArray(values) ? input.from(table).insert(values, options) : input.from(table).insert(values, options);
-    },
-    upsert(table, values, options) {
-      return Array.isArray(values) ? input.from(table).upsert(values, options) : input.from(table).upsert(values, options);
-    },
-    update(table, values, options) {
-      return input.from(table).update(values, options);
-    },
-    delete(table, options) {
-      return input.from(table).delete(options);
-    },
-    rpc(fn, args, options) {
-      return input.rpc(fn, args, options);
-    },
-    query(query, options) {
-      return input.query(query, options);
-    }
-  };
-  return db;
-}
-
 // src/storage/file.ts
 function createStorageFileModule(base, config = {}) {
   const upload = async (input, options) => {
@@ -8436,7 +8412,30 @@ function createClientFromConfig(config, sourceConfig) {
     config.experimental,
     queryTracer
   );
-  const db = createDbModule({ from, rpc, query });
+  const untypedDbFrom = from;
+  const db = {
+    from,
+    select(table, first, second) {
+      if (first && typeof first === "object" && !Array.isArray(first)) {
+        return untypedDbFrom(table).select(void 0, first);
+      }
+      return untypedDbFrom(table).select(first, second);
+    },
+    insert(table, values, options) {
+      return Array.isArray(values) ? untypedDbFrom(table).insert(values, options) : untypedDbFrom(table).insert(values, options);
+    },
+    upsert(table, values, options) {
+      return Array.isArray(values) ? untypedDbFrom(table).upsert(values, options) : untypedDbFrom(table).upsert(values, options);
+    },
+    update(table, values, options) {
+      return untypedDbFrom(table).update(values, options);
+    },
+    delete(table, options) {
+      return untypedDbFrom(table).delete(options);
+    },
+    rpc,
+    query
+  };
   const chat = createChatModule({
     baseUrl: config.chatUrl,
     apiKey: config.apiKey,
@@ -8587,7 +8586,9 @@ function createClientFromConfig(config, sourceConfig) {
 var AthenaClient = class {
   /** Create a fluent builder for a strongly-typed Athena SDK client. */
   static builder() {
-    return createAthenaClientBuilder((config) => createClientFromInput(config));
+    return createAthenaClientBuilder(
+      (config) => createClientFromInput(config)
+    );
   }
   static fromEnvironment(options = {}) {
     const env = options.env ?? process.env;
@@ -8618,11 +8619,12 @@ var AthenaClient = class {
     });
   }
 };
-function createClient(configOrUrl, apiKey, options) {
+function createClient(...args) {
+  const [configOrUrl, apiKey, options] = args;
   if (typeof configOrUrl === "string" || configOrUrl === null || configOrUrl === void 0) {
     return createClientFromInput({
       url: configOrUrl,
-      key: "",
+      key: apiKey ?? "",
       ...options
     });
   }
@@ -8758,6 +8760,237 @@ function buildSessionClientOptions(context, options) {
   };
 }
 
+// src/next/session-bridge/constants.ts
+var ATHENA_AUTH_SESSION_BRIDGE_ROUTE = "/api/athena-auth/session";
+var ATHENA_AUTH_SESSION_COOKIE_NAME = "athena-auth.session-token";
+var ATHENA_AUTH_SESSION_COOKIE_NAMES = [
+  ATHENA_AUTH_SESSION_COOKIE_NAME,
+  "athena-auth.session_token"
+];
+
+// src/next/session-bridge/client.ts
+var JSON_CONTENT_TYPE = "application/json";
+function isBrowserRuntime() {
+  return typeof globalThis !== "undefined" && "window" in globalThis;
+}
+async function persistAthenaAuthSessionOnAppHost(payload, options) {
+  if (!(payload && isBrowserRuntime())) {
+    return;
+  }
+  const route = options?.route ?? ATHENA_AUTH_SESSION_BRIDGE_ROUTE;
+  const fetchImpl = options?.fetch ?? fetch;
+  const response = await fetchImpl(route, {
+    body: JSON.stringify(payload),
+    credentials: "same-origin",
+    headers: {
+      "Content-Type": JSON_CONTENT_TYPE
+    },
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new Error("Failed to persist the Athena Auth session on the app host");
+  }
+}
+async function clearAthenaAuthSessionOnAppHost(options) {
+  if (!isBrowserRuntime()) {
+    return;
+  }
+  const route = options?.route ?? ATHENA_AUTH_SESSION_BRIDGE_ROUTE;
+  const fetchImpl = options?.fetch ?? fetch;
+  const response = await fetchImpl(route, {
+    credentials: "same-origin",
+    method: "DELETE"
+  });
+  if (!response.ok) {
+    throw new Error("Failed to clear the Athena Auth session on the app host");
+  }
+}
+
+// src/next/session-bridge/payload.ts
+function resolveSessionBridgePayload(payload) {
+  const token = payload?.session?.token ?? payload?.token;
+  if (typeof token !== "string") {
+    return null;
+  }
+  const normalizedToken = token.trim();
+  if (!normalizedToken) {
+    return null;
+  }
+  return {
+    token: normalizedToken,
+    expiresAt: typeof payload?.session?.expiresAt === "string" ? payload.session.expiresAt : void 0
+  };
+}
+
+// src/next/session-bridge/cookie.ts
+var EXPIRED_AT = /* @__PURE__ */ new Date(0);
+function resolveRequestIsSecure(request2) {
+  const forwardedProto = request2.headers.get("x-forwarded-proto")?.trim();
+  if (forwardedProto) {
+    const first = forwardedProto.split(",")[0]?.trim().toLowerCase();
+    if (first === "https") return true;
+    if (first === "http") return false;
+  }
+  return new URL(request2.url).protocol === "https:";
+}
+function resolveSessionCookieExpiresAt(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const expiresAt = new Date(value);
+  return Number.isNaN(expiresAt.getTime()) ? void 0 : expiresAt;
+}
+function serializeCookie(name, value, options) {
+  const parts = [
+    `${encodeURIComponent(name)}=${encodeURIComponent(value)}`,
+    `Path=${options.path}`,
+    "HttpOnly",
+    `SameSite=${options.sameSite === "none" ? "None" : options.sameSite === "strict" ? "Strict" : "Lax"}`
+  ];
+  if (options.secure) {
+    parts.push("Secure");
+  }
+  if (options.expires) {
+    parts.push(`Expires=${options.expires.toUTCString()}`);
+  }
+  return parts.join("; ");
+}
+function resolveBridgeCookieConfig(options) {
+  return {
+    cookieName: options?.cookieName ?? ATHENA_AUTH_SESSION_COOKIE_NAME,
+    cookieNames: options?.cookieNames ?? ATHENA_AUTH_SESSION_COOKIE_NAMES,
+    cookiePath: options?.cookiePath ?? "/",
+    sameSite: options?.sameSite ?? "lax"
+  };
+}
+function appendSessionCookie(headers, request2, token, expiresAt, options) {
+  const config = resolveBridgeCookieConfig(options);
+  const secure = options?.secure ?? resolveRequestIsSecure(request2);
+  headers.append(
+    "set-cookie",
+    serializeCookie(config.cookieName, token, {
+      path: config.cookiePath,
+      sameSite: config.sameSite,
+      secure,
+      expires: expiresAt
+    })
+  );
+}
+function appendClearSessionCookies(headers, request2, options) {
+  const config = resolveBridgeCookieConfig(options);
+  const secure = options?.secure ?? resolveRequestIsSecure(request2);
+  const names = /* @__PURE__ */ new Set([config.cookieName, ...config.cookieNames]);
+  for (const name of names) {
+    headers.append(
+      "set-cookie",
+      serializeCookie(name, "", {
+        path: config.cookiePath,
+        sameSite: config.sameSite,
+        secure,
+        expires: EXPIRED_AT
+      })
+    );
+  }
+}
+
+// src/next/session-bridge/handlers.ts
+function json(body, init) {
+  const headers = init?.headers ?? new Headers();
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
+  return new Response(JSON.stringify(body), {
+    status: init?.status ?? 200,
+    headers
+  });
+}
+function resolveRoute(options) {
+  return options?.route ?? ATHENA_AUTH_SESSION_BRIDGE_ROUTE;
+}
+async function handleAthenaAuthSessionBridgePost(request2, options) {
+  const payload = await request2.json().catch(() => null);
+  const token = typeof payload?.token === "string" ? payload.token.trim() : "";
+  if (!token) {
+    return json(
+      {
+        error: "Missing Athena Auth session token"
+      },
+      { status: 400 }
+    );
+  }
+  const headers = new Headers();
+  appendSessionCookie(
+    headers,
+    request2,
+    token,
+    resolveSessionCookieExpiresAt(payload?.expiresAt),
+    options
+  );
+  return json(
+    {
+      ok: true,
+      route: resolveRoute(options)
+    },
+    { headers }
+  );
+}
+function handleAthenaAuthSessionBridgeDelete(request2, options) {
+  const headers = new Headers();
+  appendClearSessionCookies(headers, request2, options);
+  return json(
+    {
+      ok: true,
+      route: resolveRoute(options)
+    },
+    { headers }
+  );
+}
+function createAthenaAuthSessionBridgeHandlers(options) {
+  return {
+    POST: (request2) => handleAthenaAuthSessionBridgePost(request2, options),
+    DELETE: (request2) => handleAthenaAuthSessionBridgeDelete(request2, options)
+  };
+}
+function normalizePathname(pathname) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.slice(0, -1);
+  }
+  return pathname || "/";
+}
+function isAthenaAuthSessionBridgePath(request2, options) {
+  const pathname = normalizePathname(new URL(request2.url).pathname);
+  const route = normalizePathname(resolveRoute(options));
+  if (pathname === route) {
+    return true;
+  }
+  const matchPaths = options?.matchPaths ?? ["session"];
+  const segments = pathname.split("/").filter(Boolean);
+  const tail = segments[segments.length - 1];
+  return typeof tail === "string" && matchPaths.includes(tail);
+}
+function createAthenaAuthSessionBridgePathHandlers(options) {
+  const notFound = () => json(
+    {
+      error: "Not found"
+    },
+    { status: 404 }
+  );
+  return {
+    POST: async (request2) => {
+      if (!isAthenaAuthSessionBridgePath(request2, options)) {
+        return notFound();
+      }
+      return handleAthenaAuthSessionBridgePost(request2, options);
+    },
+    DELETE: (request2) => {
+      if (!isAthenaAuthSessionBridgePath(request2, options)) {
+        return notFound();
+      }
+      return handleAthenaAuthSessionBridgeDelete(request2, options);
+    }
+  };
+}
+
 // src/next/server.ts
 function resolveUserId(session) {
   return session?.user?.id ?? null;
@@ -8796,7 +9029,20 @@ async function resolveAthenaServerContext(options) {
   };
 }
 
+exports.ATHENA_AUTH_SESSION_BRIDGE_ROUTE = ATHENA_AUTH_SESSION_BRIDGE_ROUTE;
+exports.ATHENA_AUTH_SESSION_COOKIE_NAME = ATHENA_AUTH_SESSION_COOKIE_NAME;
+exports.ATHENA_AUTH_SESSION_COOKIE_NAMES = ATHENA_AUTH_SESSION_COOKIE_NAMES;
+exports.SESSION_COOKIE_PATTERNS = SESSION_COOKIE_PATTERNS;
+exports.clearAthenaAuthSessionOnAppHost = clearAthenaAuthSessionOnAppHost;
+exports.createAthenaAuthSessionBridgeHandlers = createAthenaAuthSessionBridgeHandlers;
+exports.createAthenaAuthSessionBridgePathHandlers = createAthenaAuthSessionBridgePathHandlers;
 exports.createAthenaServerClient = createAthenaServerClient;
+exports.handleAthenaAuthSessionBridgeDelete = handleAthenaAuthSessionBridgeDelete;
+exports.handleAthenaAuthSessionBridgePost = handleAthenaAuthSessionBridgePost;
+exports.hasAuthSessionCookie = hasAuthSessionCookie;
+exports.isAthenaAuthSessionBridgePath = isAthenaAuthSessionBridgePath;
+exports.persistAthenaAuthSessionOnAppHost = persistAthenaAuthSessionOnAppHost;
 exports.resolveAthenaServerContext = resolveAthenaServerContext;
+exports.resolveSessionBridgePayload = resolveSessionBridgePayload;
 //# sourceMappingURL=server.cjs.map
 //# sourceMappingURL=server.cjs.map