@xylex-group/athena 2.4.0 → 2.4.1

package/dist/index.js

@@ -130,12 +130,47 @@ function buildAthenaGatewayUrl(baseUrl, path) {
   return `${baseUrl}${path}`;
 }
 
+// src/cookies/cookie-utils.ts
+var SECURE_COOKIE_PREFIX = "__Secure-";
+function parseCookies(cookieHeader) {
+  const cookies = cookieHeader.split("; ");
+  const cookieMap = /* @__PURE__ */ new Map();
+  cookies.forEach((cookie) => {
+    const [name, value] = cookie.split(/=(.*)/s);
+    cookieMap.set(name, value);
+  });
+  return cookieMap;
+}
+var getSessionCookie = (request, config) => {
+  const cookies = (request instanceof Headers || !("headers" in request) ? request : request.headers).get("cookie");
+  if (!cookies) {
+    return null;
+  }
+  const { cookieName = "session_token", cookiePrefix = "athena-auth" } = {};
+  const parsedCookie = parseCookies(cookies);
+  const getCookie = (name) => parsedCookie.get(name) || parsedCookie.get(`${SECURE_COOKIE_PREFIX}${name}`);
+  const sessionToken = getCookie(`${cookiePrefix}.${cookieName}`) || getCookie(`${cookiePrefix}-${cookieName}`);
+  if (sessionToken) {
+    return sessionToken;
+  }
+  return null;
+};
+
+// package.json
+var package_default = {
+  version: "2.4.1"
+};
+
+// src/sdk-version.ts
+var PACKAGE_VERSION = package_default.version;
+function buildSdkHeaderValue(sdkName) {
+  return `${sdkName} ${PACKAGE_VERSION}`;
+}
+
 // src/gateway/client.ts
 var DEFAULT_CLIENT = "railway_direct";
-var FALLBACK_SDK_VERSION = "1.3.0";
 var SDK_NAME = "xylex-group/athena";
-var SDK_VERSION = typeof process !== "undefined" && process?.env?.npm_package_version ? process.env.npm_package_version : FALLBACK_SDK_VERSION;
-var SDK_HEADER_VALUE = `${SDK_NAME} ${SDK_VERSION}`;
+var SDK_HEADER_VALUE = buildSdkHeaderValue(SDK_NAME);
 function parseResponseBody(rawText, contentType) {
   if (!rawText) {
     return { parsed: null, parseFailed: false };
@@ -154,6 +189,37 @@ function parseResponseBody(rawText, contentType) {
 function normalizeHeaderValue(value) {
   return value ? value : void 0;
 }
+function resolveHeaderValue(headers, candidates) {
+  for (const candidate of candidates) {
+    const direct = normalizeHeaderValue(headers[candidate]);
+    if (direct) return direct;
+  }
+  const loweredCandidates = new Set(candidates.map((candidate) => candidate.toLowerCase()));
+  for (const [key, value] of Object.entries(headers)) {
+    if (!loweredCandidates.has(key.toLowerCase())) {
+      continue;
+    }
+    const normalized = normalizeHeaderValue(value);
+    if (normalized) return normalized;
+  }
+  return void 0;
+}
+function resolveBearerTokenFromAuthorizationHeader(headers) {
+  const authorization = resolveHeaderValue(headers, ["Authorization"]);
+  if (!authorization) {
+    return void 0;
+  }
+  const match = authorization.match(/^Bearer\s+(.+)$/i);
+  const token = match?.[1]?.trim();
+  return token ? token : void 0;
+}
+function resolveSessionTokenFromCookieHeader(headers) {
+  const cookie = resolveHeaderValue(headers, ["Cookie"]);
+  if (!cookie) {
+    return void 0;
+  }
+  return getSessionCookie(new Headers({ cookie })) ?? void 0;
+}
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -271,7 +337,7 @@ function buildRpcGetEndpoint(payload) {
           status: 0
         });
       }
-      query.set(filter.column, toRpcFilterQueryValue(filter));
+      query.append(filter.column, toRpcFilterQueryValue(filter));
     }
   }
   const endpoint = `/rpc/${encodeURIComponent(functionName)}`;
@@ -317,6 +383,20 @@ function buildHeaders(config, options) {
     headers["apikey"] = finalApiKey;
     headers["x-api-key"] = headers["x-api-key"] ?? finalApiKey;
   }
+  const explicitSessionToken = resolveHeaderValue(extraHeaders, [
+    "X-Athena-Auth-Session-Token"
+  ]);
+  const derivedSessionToken = explicitSessionToken ?? resolveSessionTokenFromCookieHeader(extraHeaders);
+  if (derivedSessionToken) {
+    headers["X-Athena-Auth-Session-Token"] = derivedSessionToken;
+  }
+  const explicitBearerToken = resolveHeaderValue(extraHeaders, [
+    "X-Athena-Auth-Bearer-Token"
+  ]);
+  const derivedBearerToken = explicitBearerToken ?? resolveBearerTokenFromAuthorizationHeader(extraHeaders);
+  if (derivedBearerToken) {
+    headers["X-Athena-Auth-Bearer-Token"] = derivedBearerToken;
+  }
   const athenaClientKeys = ["x-athena-client", "X-Athena-Client"];
   Object.entries(extraHeaders).forEach(([key, value]) => {
     if (athenaClientKeys.includes(key)) return;
@@ -1012,10 +1092,8 @@ async function resolveReactEmailPayloadFields(input, fields, options) {
 
 // src/auth/client.ts
 var DEFAULT_AUTH_BASE_URL = "http://localhost:3001/api/auth";
-var FALLBACK_SDK_VERSION2 = "1.0.0";
 var SDK_NAME2 = "xylex-group/athena-auth";
-var SDK_VERSION2 = typeof process !== "undefined" && process?.env?.npm_package_version ? process.env.npm_package_version : FALLBACK_SDK_VERSION2;
-var SDK_HEADER_VALUE2 = `${SDK_NAME2} ${SDK_VERSION2}`;
+var SDK_HEADER_VALUE2 = buildSdkHeaderValue(SDK_NAME2);
 function normalizeBaseUrl(baseUrl) {
   return (baseUrl ?? DEFAULT_AUTH_BASE_URL).replace(/\/$/, "");
 }
@@ -3000,7 +3078,7 @@ function buildStructuredWhere(conditions) {
     if (!condition.column) {
       return null;
     }
-    if (condition.column_cast !== void 0 || condition.value_cast !== void 0) {
+    if (condition.value_cast !== void 0) {
       return null;
     }
     const operand = condition.value;
@@ -3079,6 +3157,104 @@ function toFindManyAstOrder(order) {
     ascending: order.direction !== "descending"
   };
 }
+function isRecord6(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeFindManyAstColumnPredicate(value) {
+  if (!isRecord6(value)) {
+    return {
+      eq: value
+    };
+  }
+  const normalized = {};
+  for (const [key, operand] of Object.entries(value)) {
+    if (operand !== void 0) {
+      normalized[key] = operand;
+    }
+  }
+  return normalized;
+}
+function normalizeFindManyAstBooleanOperand(clause) {
+  const normalized = {};
+  for (const [column, value] of Object.entries(clause)) {
+    if (value === void 0) {
+      continue;
+    }
+    normalized[column] = normalizeFindManyAstColumnPredicate(value);
+  }
+  return normalized;
+}
+function normalizeFindManyAstWhere(where) {
+  if (!where || !isRecord6(where)) {
+    return where;
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (key === "or" && Array.isArray(value)) {
+      normalized.or = value.map(
+        (clause) => normalizeFindManyAstBooleanOperand(clause)
+      );
+      continue;
+    }
+    if (key === "not" && isRecord6(value)) {
+      normalized.not = normalizeFindManyAstBooleanOperand(
+        value
+      );
+      continue;
+    }
+    normalized[key] = normalizeFindManyAstColumnPredicate(value);
+  }
+  return normalized;
+}
+function predicateRequiresUuidQueryFallback(column, value) {
+  if (!isRecord6(value)) {
+    return shouldUseUuidTextComparison(column, value);
+  }
+  const eqValue = value.eq;
+  return eqValue !== void 0 && shouldUseUuidTextComparison(column, eqValue);
+}
+function booleanOperandRequiresUuidQueryFallback(clause) {
+  for (const [column, value] of Object.entries(clause)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (predicateRequiresUuidQueryFallback(column, value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function findManyAstWhereRequiresLegacyTransport(where) {
+  if (!where || !isRecord6(where)) {
+    return false;
+  }
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (key === "or" && Array.isArray(value)) {
+      if (value.some(
+        (clause) => booleanOperandRequiresUuidQueryFallback(clause)
+      )) {
+        return true;
+      }
+      continue;
+    }
+    if (key === "not" && isRecord6(value)) {
+      if (booleanOperandRequiresUuidQueryFallback(value)) {
+        return true;
+      }
+      continue;
+    }
+    if (predicateRequiresUuidQueryFallback(key, value)) {
+      return true;
+    }
+  }
+  return false;
+}
 function resolvePagination(input) {
   let limit = input.limit;
   let offset = input.offset;
@@ -3097,25 +3273,6 @@ function hasTypedEqualityComparison(conditions) {
 }
 function createSelectTransportPlan(input) {
   const conditions = input.state.conditions.length ? input.state.conditions.map((condition) => ({ ...condition })) : void 0;
-  if (hasTypedEqualityComparison(conditions) && !input.options?.head && !input.options?.count && conditions) {
-    const query = input.buildTypedSelectQuery({
-      tableName: input.tableName,
-      columns: input.columns,
-      conditions,
-      limit: input.state.limit,
-      offset: input.state.offset,
-      currentPage: input.state.currentPage,
-      pageSize: input.state.pageSize,
-      order: input.state.order
-    });
-    if (query) {
-      return {
-        kind: "query",
-        query,
-        payload: { query }
-      };
-    }
-  }
   const pagination = resolvePagination({
     limit: input.state.limit,
     offset: input.state.offset,
@@ -3151,6 +3308,25 @@ function createSelectTransportPlan(input) {
       }
     };
   }
+  if (hasTypedEqualityComparison(conditions) && !input.options?.head && !input.options?.count && conditions) {
+    const query = input.buildTypedSelectQuery({
+      tableName: input.tableName,
+      columns: input.columns,
+      conditions,
+      limit: input.state.limit,
+      offset: input.state.offset,
+      currentPage: input.state.currentPage,
+      pageSize: input.state.pageSize,
+      order: input.state.order
+    });
+    if (query) {
+      return {
+        kind: "query",
+        query,
+        payload: { query }
+      };
+    }
+  }
   return {
     kind: "fetch",
     payload: {
@@ -3207,6 +3383,13 @@ function formatResult(response) {
   }
   return result;
 }
+var EXPERIMENTAL_READ_RETRY_CONFIG = {
+  retries: 2,
+  baseDelayMs: 100,
+  maxDelayMs: 1e3,
+  backoff: "exponential",
+  jitter: true
+};
 function attachNormalizedError(result, normalizedError) {
   Object.defineProperty(result, ATHENA_NORMALIZED_ERROR_KEY, {
     value: normalizedError,
@@ -3233,7 +3416,36 @@ function createResultFormatter(experimental) {
     return result;
   };
 }
-function isRecord6(value) {
+async function executeExperimentalRead(experimental, runner) {
+  if (!experimental?.retryReads) {
+    return runner();
+  }
+  let lastRetryableResult;
+  let lastRetrySignal = null;
+  try {
+    return await withRetry(
+      {
+        ...EXPERIMENTAL_READ_RETRY_CONFIG,
+        shouldRetry: (error) => error === lastRetrySignal || normalizeAthenaError(error).retryable
+      },
+      async () => {
+        const result = await runner();
+        if (result.error?.retryable) {
+          lastRetryableResult = result;
+          lastRetrySignal = result.error;
+          throw lastRetrySignal;
+        }
+        return result;
+      }
+    );
+  } catch (error) {
+    if (lastRetryableResult && error === lastRetrySignal) {
+      return lastRetryableResult;
+    }
+    throw error;
+  }
+}
+function isRecord7(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function firstNonEmptyString2(...values) {
@@ -3245,8 +3457,8 @@ function firstNonEmptyString2(...values) {
   return void 0;
 }
 function resolveStructuredErrorPayload2(raw) {
-  if (!isRecord6(raw)) return null;
-  return isRecord6(raw.error) ? raw.error : raw;
+  if (!isRecord7(raw)) return null;
+  return isRecord7(raw.error) ? raw.error : raw;
 }
 function resolveStructuredErrorDetails(payload, message) {
   if (!payload || !("details" in payload)) {
@@ -3262,7 +3474,7 @@ function resolveStructuredErrorDetails(payload, message) {
   return details;
 }
 function createResultError(response, result, normalized) {
-  const rawRecord = isRecord6(response.raw) ? response.raw : null;
+  const rawRecord = isRecord7(response.raw) ? response.raw : null;
   const payload = resolveStructuredErrorPayload2(response.raw);
   const message = firstNonEmptyString2(
     response.error,
@@ -3457,7 +3669,14 @@ function toSingleResult(response) {
 function mergeOptions(...options) {
   return options.reduce((acc, next) => {
     if (!next) return acc;
-    return { ...acc, ...next };
+    const merged = { ...acc ?? {}, ...next };
+    if (acc?.headers || next.headers) {
+      merged.headers = {
+        ...acc?.headers ?? {},
+        ...next.headers ?? {}
+      };
+    }
+    return merged;
   }, void 0);
 }
 function asAthenaJsonObject(value) {
@@ -4249,42 +4468,48 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
       buildTypedSelectQuery
     });
     if (plan.kind === "query") {
-      return executeWithQueryTrace(
+      return executeExperimentalRead(
+        experimental,
+        () => executeWithQueryTrace(
+          tracer,
+          {
+            operation: "select",
+            endpoint: "/gateway/query",
+            table: resolvedTableName,
+            sql: plan.query,
+            payload: plan.payload,
+            options
+          },
+          async () => {
+            const queryResponse = await client.queryGateway(plan.payload, options);
+            return formatGatewayResult(queryResponse, { table: resolvedTableName, operation: "select" });
+          },
+          callsite
+        )
+      );
+    }
+    const sql = buildDebugSelectQuery({
+      tableName: resolvedTableName,
+      ...plan.debug
+    });
+    return executeExperimentalRead(
+      experimental,
+      () => executeWithQueryTrace(
         tracer,
         {
           operation: "select",
-          endpoint: "/gateway/query",
+          endpoint: "/gateway/fetch",
           table: resolvedTableName,
-          sql: plan.query,
+          sql,
           payload: plan.payload,
           options
         },
         async () => {
-          const queryResponse = await client.queryGateway(plan.payload, options);
-          return formatGatewayResult(queryResponse, { table: resolvedTableName, operation: "select" });
+          const response = await client.fetchGateway(plan.payload, options);
+          return formatGatewayResult(response, { table: resolvedTableName, operation: "select" });
         },
         callsite
-      );
-    }
-    const sql = buildDebugSelectQuery({
-      tableName: resolvedTableName,
-      ...plan.debug
-    });
-    return executeWithQueryTrace(
-      tracer,
-      {
-        operation: "select",
-        endpoint: "/gateway/fetch",
-        table: resolvedTableName,
-        sql,
-        payload: plan.payload,
-        options
-      },
-      async () => {
-        const response = await client.fetchGateway(plan.payload, options);
-        return formatGatewayResult(response, { table: resolvedTableName, operation: "select" });
-      },
-      callsite
+      )
     );
   };
   const createSelectChain = (columns, options, initialCallsite) => {
@@ -4354,14 +4579,14 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
       if (options.limit !== void 0) {
         executionState.limit = options.limit;
       }
-      if (experimental?.findManyAst && canUseFindManyAstTransport(baseState) && !selectShapeUsesRelationSchema(options.select)) {
+      if (experimental?.findManyAst && canUseFindManyAstTransport(baseState) && !selectShapeUsesRelationSchema(options.select) && !findManyAstWhereRequiresLegacyTransport(options.where)) {
         const resolvedTableName = resolveTableNameForCall(tableName, void 0);
         const payload = {
           table_name: resolvedTableName,
           select: options.select
         };
         if (options.where !== void 0) {
-          payload.where = options.where;
+          payload.where = normalizeFindManyAstWhere(options.where);
         }
         const astOrder = toFindManyAstOrder(executionState.order);
         if (astOrder !== void 0) {
@@ -4377,22 +4602,25 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
           limit: executionState.limit,
           order: executionState.order
         });
-        return executeWithQueryTrace(
-          tracer,
-          {
-            operation: "select",
-            endpoint: "/gateway/fetch",
-            table: resolvedTableName,
-            sql,
-            payload
-          },
-          async () => {
-            const response = await client.fetchGateway(
+        return executeExperimentalRead(
+          experimental,
+          () => executeWithQueryTrace(
+            tracer,
+            {
+              operation: "select",
+              endpoint: "/gateway/fetch",
+              table: resolvedTableName,
+              sql,
               payload
-            );
-            return formatGatewayResult(response, { table: resolvedTableName, operation: "select" });
-          },
-          callsite
+            },
+            async () => {
+              const response = await client.fetchGateway(
+                payload
+              );
+              return formatGatewayResult(response, { table: resolvedTableName, operation: "select" });
+            },
+            callsite
+          )
         );
       }
       return runSelect(
@@ -4640,7 +4868,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
   });
   return builder;
 }
-function createQueryBuilder(client, formatGatewayResult, tracer) {
+function createQueryBuilder(client, formatGatewayResult, experimental, tracer) {
   return async function query(query, options) {
     const normalizedQuery = query.trim();
     if (!normalizedQuery) {
@@ -4648,30 +4876,39 @@ function createQueryBuilder(client, formatGatewayResult, tracer) {
     }
     const payload = { query: normalizedQuery };
     const callsite = captureTraceCallsite(tracer);
-    return executeWithQueryTrace(
-      tracer,
-      {
-        operation: "query",
-        endpoint: "/gateway/query",
-        sql: normalizedQuery,
-        payload,
-        options
-      },
-      async () => {
-        const response = await client.queryGateway(payload, options);
-        return formatGatewayResult(response, { operation: "query" });
-      },
-      callsite
+    return executeExperimentalRead(
+      experimental,
+      () => executeWithQueryTrace(
+        tracer,
+        {
+          operation: "query",
+          endpoint: "/gateway/query",
+          sql: normalizedQuery,
+          payload,
+          options
+        },
+        async () => {
+          const response = await client.queryGateway(payload, options);
+          return formatGatewayResult(response, { operation: "query" });
+        },
+        callsite
+      )
     );
   };
 }
 function createClientFromConfig(config) {
+  const gatewayHeaders = {
+    ...config.headers ?? {}
+  };
+  if (config.auth?.bearerToken && gatewayHeaders["X-Athena-Auth-Bearer-Token"] === void 0 && gatewayHeaders["x-athena-auth-bearer-token"] === void 0) {
+    gatewayHeaders["X-Athena-Auth-Bearer-Token"] = config.auth.bearerToken;
+  }
   const gateway = createAthenaGatewayClient({
     baseUrl: config.baseUrl,
     apiKey: config.apiKey,
     client: config.client,
     backend: config.backend,
-    headers: config.headers
+    headers: gatewayHeaders
   });
   const formatGatewayResult = createResultFormatter(config.experimental);
   const queryTracer = createQueryTracer(config.experimental);
@@ -4698,7 +4935,7 @@ function createClientFromConfig(config) {
       captureTraceCallsite(queryTracer)
     );
   };
-  const query = createQueryBuilder(gateway, formatGatewayResult, queryTracer);
+  const query = createQueryBuilder(gateway, formatGatewayResult, config.experimental, queryTracer);
   const db = createDbModule({ from, rpc, query });
   return {
     from,
@@ -4748,7 +4985,6 @@ var AthenaClientBuilderImpl = class {
   defaultHeaders;
   authConfig;
   experimentalOptions;
-  isHealthTrackingEnabled = false;
   url(url) {
     this.baseUrl = url;
     return this;
@@ -4798,10 +5034,6 @@ var AthenaClientBuilderImpl = class {
     }
     return this;
   }
-  healthTracking(enabled) {
-    this.isHealthTrackingEnabled = enabled;
-    return this;
-  }
   build() {
     if (!this.baseUrl || !this.apiKey) {
       throw new Error("AthenaClient requires url and key; call .url() and .key() before .build()");
@@ -4812,7 +5044,6 @@ var AthenaClientBuilderImpl = class {
       client: this.clientName,
       backend: this.backendConfig,
       headers: this.defaultHeaders,
-      healthTracking: this.isHealthTrackingEnabled,
       auth: this.authConfig,
       experimental: this.experimentalOptions
     });
@@ -5432,7 +5663,7 @@ function resolveNullishValue(mode) {
   if (mode === "null") return null;
   return "";
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNullableColumn(model, key) {
@@ -5441,7 +5672,7 @@ function isNullableColumn(model, key) {
 }
 function toModelFormDefaults(model, values, options) {
   const source = values;
-  if (!isRecord7(source)) {
+  if (!isRecord8(source)) {
     return {};
   }
   const mode = options?.nullishMode ?? "empty-string";