@xylex-group/athena 2.11.0 → 2.12.1

package/dist/{pipeline-DZMsPxUg.d.ts → pipeline-DrjU2vNA.d.ts}

@@ -1,4 +1,4 @@
-import { R as RunGeneratorOptions, s as RunGeneratorResult } from './types-CRjDwmtJ.js';
+import { R as RunGeneratorOptions, s as RunGeneratorResult } from './types-DRRb0Fd0.js';
 
 /**
  * End-to-end generator execution: load config, introspect, render, and optionally write files.

package/dist/{pipeline-CmUZsXsi.d.cts → pipeline-c7Gdm0qv.d.cts}

@@ -1,4 +1,4 @@
-import { R as RunGeneratorOptions, s as RunGeneratorResult } from './types-C-YvfgYh.cjs';
+import { R as RunGeneratorOptions, s as RunGeneratorResult } from './types-BLizCLd1.cjs';
 
 /**
  * End-to-end generator execution: load config, introspect, render, and optionally write files.

package/dist/react.cjs

@@ -185,42 +185,31 @@ var getSessionCookie = (request, config) => {
   return null;
 };
 
-// package.json
-var package_default = {
-  version: "2.11.0"
-};
-
-// 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 SDK_NAME = "xylex-group/athena";
-var SDK_HEADER_VALUE = buildSdkHeaderValue(SDK_NAME);
+// src/utils/athena-request-headers.ts
 var NO_CACHE_HEADER_VALUE = "no-cache";
-function parseResponseBody(rawText, contentType) {
-  if (!rawText) {
-    return { parsed: null, parseFailed: false };
-  }
-  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
-  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
-  if (!looksJson) {
-    return { parsed: rawText, parseFailed: false };
-  }
-  try {
-    return { parsed: JSON.parse(rawText), parseFailed: false };
-  } catch {
-    return { parsed: rawText, parseFailed: true };
-  }
-}
+var API_KEY_HEADER_CANDIDATES = ["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"];
+var CLIENT_HEADER_CANDIDATES = ["X-Athena-Client", "x-athena-client"];
+var PG_URI_HEADER_CANDIDATES = ["x-pg-uri"];
+var JDBC_URI_HEADER_CANDIDATES = ["x-athena-jdbc-url", "x-jdbc-url"];
+var PROFILE_RULES = {
+  gateway: { apiKeys: true, routing: true, authMirror: true, authBearer: false, contentType: true, stripNullsDefault: true },
+  chat: { apiKeys: true, routing: true, authMirror: true, authBearer: true, accept: true },
+  storage: { apiKeys: true, routing: true, authMirror: true, authBearer: false, contentType: true },
+  auth: { apiKeys: true, routing: false, authMirror: false, authBearer: true, contentType: true },
+  minimal: { apiKeys: false, routing: false, authMirror: false, authBearer: false }
+};
 function normalizeHeaderValue(value) {
   return value ? value : void 0;
 }
-function isCacheControlHeaderName(name) {
-  return name.toLowerCase() === "cache-control";
+function mergeExtraHeaders(configHeaders, callHeaders) {
+  return { ...configHeaders ?? {}, ...callHeaders ?? {} };
+}
+function hasHeaderIgnoreCase(headers, targetKey) {
+  const normalizedTargetKey = targetKey.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === normalizedTargetKey);
 }
 function resolveHeaderValue(headers, candidates) {
   for (const candidate of candidates) {
@@ -237,13 +226,20 @@ function resolveHeaderValue(headers, candidates) {
   }
   return void 0;
 }
+function isCacheControlHeaderName(name) {
+  return name.toLowerCase() === "cache-control";
+}
+function normalizeBearerToken(value) {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^Bearer\s+(.+)$/i);
+  return match?.[1]?.trim() ?? trimmed;
+}
 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();
+  const token = normalizeBearerToken(authorization);
   return token ? token : void 0;
 }
 function resolveSessionTokenFromCookieHeader(headers) {
@@ -253,6 +249,210 @@ function resolveSessionTokenFromCookieHeader(headers) {
   }
   return getSessionCookie(new Headers({ cookie })) ?? void 0;
 }
+function resolveBackendType(backend) {
+  if (!backend) {
+    return void 0;
+  }
+  return typeof backend === "string" ? backend : backend.type;
+}
+function resolveRequestHeaderOverrides(config, options, defaults) {
+  return {
+    apiKey: options?.apiKey ?? config.apiKey,
+    athenaKey: options?.athenaKey ?? config.athenaKey,
+    client: options?.client ?? config.client ?? defaults?.client,
+    userId: options?.userId ?? config.userId,
+    organizationId: options?.organizationId ?? config.organizationId,
+    backend: options?.backend ?? config.backend,
+    publishEvent: options?.publishEvent ?? config.publishEvent,
+    stripNulls: options?.stripNulls ?? config.stripNulls ?? defaults?.stripNulls,
+    bearerToken: options?.bearerToken ?? config.bearerToken,
+    cookie: options?.cookie ?? config.cookie,
+    sessionToken: options?.sessionToken ?? config.sessionToken,
+    pgUri: options?.pgUri ?? config.pgUri,
+    jdbcUrl: options?.jdbcUrl ?? config.jdbcUrl,
+    forceNoCache: Boolean(config.forceNoCache || options?.forceNoCache),
+    configHeaders: config.headers,
+    callHeaders: options?.headers
+  };
+}
+function buildServiceRequestHeaders(profile, sdkHeaderValue, config, options, extras) {
+  const rules = PROFILE_RULES[profile];
+  return buildAthenaRequestHeaders({
+    profile,
+    sdkHeaderValue,
+    ...resolveRequestHeaderOverrides(config, options, {
+      client: extras?.client ?? void 0,
+      stripNulls: extras?.stripNulls ?? (true )
+    }),
+    contentType: extras?.contentType ?? ("application/json" ),
+    accept: extras?.accept ?? (rules.accept ? "application/json" : void 0)
+  });
+}
+function applyAthenaApiKeyHeaders(headers, apiKey, athenaKey) {
+  if (apiKey) {
+    if (!hasHeaderIgnoreCase(headers, "apikey")) {
+      headers.apikey = apiKey;
+    }
+    if (!Object.hasOwn(headers, "x-api-key")) {
+      headers["x-api-key"] = apiKey;
+    }
+    if (!Object.hasOwn(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;
+  }
+}
+function applyAthenaAuthContextHeaders(headers, input) {
+  const mergedExtraHeaders = mergeExtraHeaders(input.configHeaders, input.callHeaders);
+  const rules = PROFILE_RULES[input.profile];
+  const explicitCookie = normalizeHeaderValue(input.cookie);
+  if (explicitCookie) {
+    mergedExtraHeaders.Cookie = explicitCookie;
+  }
+  const explicitSessionToken = normalizeHeaderValue(input.sessionToken) ?? resolveHeaderValue(mergedExtraHeaders, SESSION_TOKEN_HEADER_CANDIDATES);
+  const derivedSessionToken = explicitSessionToken ?? resolveSessionTokenFromCookieHeader(mergedExtraHeaders);
+  const cookieFromHeaders = resolveHeaderValue(mergedExtraHeaders, ["Cookie"]);
+  if (explicitCookie && !hasHeaderIgnoreCase(headers, "Cookie")) {
+    headers.Cookie = explicitCookie;
+  } else if (cookieFromHeaders && !hasHeaderIgnoreCase(headers, "Cookie")) {
+    headers.Cookie = cookieFromHeaders;
+  }
+  const explicitBearerToken = (() => {
+    const configured = normalizeHeaderValue(input.bearerToken);
+    if (configured) {
+      return normalizeBearerToken(configured);
+    }
+    const mirrored = resolveHeaderValue(mergedExtraHeaders, BEARER_MIRROR_HEADER_CANDIDATES);
+    return mirrored ? normalizeBearerToken(mirrored) : void 0;
+  })();
+  const derivedBearerToken = explicitBearerToken ?? resolveBearerTokenFromAuthorizationHeader(mergedExtraHeaders);
+  if (rules.authBearer && derivedBearerToken && !hasHeaderIgnoreCase(headers, "Authorization")) {
+    headers.Authorization = `Bearer ${derivedBearerToken}`;
+  }
+  if (rules.authMirror) {
+    if (derivedSessionToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Session-Token")) {
+      headers["X-Athena-Auth-Session-Token"] = derivedSessionToken;
+    }
+    if (derivedBearerToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Bearer-Token")) {
+      headers["X-Athena-Auth-Bearer-Token"] = derivedBearerToken;
+    }
+  } else if (derivedSessionToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Session-Token")) {
+    headers["X-Athena-Auth-Session-Token"] = derivedSessionToken;
+  }
+}
+function applyAthenaPgUriHeaders(headers, input) {
+  const mergedExtraHeaders = mergeExtraHeaders(input.configHeaders, input.callHeaders);
+  const pgUri = normalizeHeaderValue(input.pgUri) ?? resolveHeaderValue(mergedExtraHeaders, PG_URI_HEADER_CANDIDATES);
+  if (pgUri && !hasHeaderIgnoreCase(headers, "x-pg-uri")) {
+    headers["x-pg-uri"] = pgUri;
+  }
+  const jdbcUrl = normalizeHeaderValue(input.jdbcUrl) ?? resolveHeaderValue(mergedExtraHeaders, JDBC_URI_HEADER_CANDIDATES);
+  if (jdbcUrl) {
+    if (!hasHeaderIgnoreCase(headers, "x-athena-jdbc-url")) {
+      headers["x-athena-jdbc-url"] = jdbcUrl;
+    }
+    if (!hasHeaderIgnoreCase(headers, "x-jdbc-url")) {
+      headers["x-jdbc-url"] = jdbcUrl;
+    }
+  }
+}
+function buildAthenaRequestHeaders(input) {
+  const forceNoCache = Boolean(input.forceNoCache);
+  const mergedExtraHeaders = mergeExtraHeaders(input.configHeaders, input.callHeaders);
+  const rules = PROFILE_RULES[input.profile];
+  const headerClient = resolveHeaderValue(mergedExtraHeaders, CLIENT_HEADER_CANDIDATES);
+  const finalClient = normalizeHeaderValue(input.client) ?? headerClient;
+  const finalApiKey = normalizeHeaderValue(input.apiKey) ?? resolveHeaderValue(mergedExtraHeaders, API_KEY_HEADER_CANDIDATES);
+  const finalAthenaKey = normalizeHeaderValue(input.athenaKey) ?? resolveHeaderValue(mergedExtraHeaders, ATHENA_KEY_HEADER_CANDIDATES) ?? finalApiKey;
+  const headers = {
+    "X-Athena-Sdk": input.sdkHeaderValue
+  };
+  if (rules.contentType) {
+    headers["Content-Type"] = input.contentType ?? "application/json";
+  }
+  if (input.accept ?? rules.accept) {
+    headers.Accept = input.accept ?? "application/json";
+  }
+  if (rules.routing) {
+    if (normalizeHeaderValue(input.userId)) {
+      headers["X-User-Id"] = input.userId ?? "";
+    }
+    if (normalizeHeaderValue(input.organizationId)) {
+      headers["X-Organization-Id"] = input.organizationId ?? "";
+    }
+    if (finalClient) {
+      headers["X-Athena-Client"] = finalClient;
+    }
+    const backendType = resolveBackendType(input.backend);
+    if (backendType) {
+      headers["X-Backend-Type"] = backendType;
+    }
+    if (typeof input.stripNulls === "boolean") {
+      headers["X-Strip-Nulls"] = input.stripNulls ? "true" : "false";
+    } else if (rules.stripNullsDefault) {
+      headers["X-Strip-Nulls"] = "true";
+    }
+    if (normalizeHeaderValue(input.publishEvent)) {
+      headers["X-Publish-Event"] = input.publishEvent ?? "";
+    }
+  }
+  if (rules.apiKeys && (finalApiKey || finalAthenaKey)) {
+    applyAthenaApiKeyHeaders(headers, finalApiKey, finalAthenaKey);
+  }
+  applyAthenaAuthContextHeaders(headers, input);
+  applyAthenaPgUriHeaders(headers, input);
+  const reservedClientHeaderKeys = new Set(CLIENT_HEADER_CANDIDATES.map((key) => key.toLowerCase()));
+  Object.entries(mergedExtraHeaders).forEach(([key, value]) => {
+    if (reservedClientHeaderKeys.has(key.toLowerCase())) {
+      return;
+    }
+    if (forceNoCache && isCacheControlHeaderName(key)) {
+      return;
+    }
+    const normalized = normalizeHeaderValue(value);
+    if (normalized) {
+      headers[key] = normalized;
+    }
+  });
+  if (forceNoCache) {
+    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE;
+  }
+  return headers;
+}
+
+// package.json
+var package_default = {
+  version: "2.12.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 SDK_NAME = "xylex-group/athena";
+var SDK_HEADER_VALUE = buildSdkHeaderValue(SDK_NAME);
+function parseResponseBody(rawText, contentType) {
+  if (!rawText) {
+    return { parsed: null, parseFailed: false };
+  }
+  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
+  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
+  if (!looksJson) {
+    return { parsed: rawText, parseFailed: false };
+  }
+  try {
+    return { parsed: JSON.parse(rawText), parseFailed: false };
+  } catch {
+    return { parsed: rawText, parseFailed: true };
+  }
+}
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -379,71 +579,10 @@ function buildRpcGetEndpoint(payload) {
   return withQuery;
 }
 function buildHeaders(config, options) {
-  const mergedStripNulls = options?.stripNulls ?? true;
-  const forceNoCache = Boolean(config.forceNoCache || options?.forceNoCache);
-  const extraHeaders = {
-    ...config.headers ?? {},
-    ...options?.headers ?? {}
-  };
-  const headerClient = extraHeaders["x-athena-client"] ?? extraHeaders["X-Athena-Client"];
-  const finalClient = options?.client ?? config.client ?? (typeof headerClient === "string" ? headerClient : void 0) ?? DEFAULT_CLIENT;
-  const finalApiKey = options?.apiKey ?? config.apiKey;
-  const finalPublishEvent = options?.publishEvent ?? config.publishEvent;
-  const headers = {
-    "Content-Type": "application/json",
-    "X-Athena-Sdk": SDK_HEADER_VALUE
-  };
-  if (options?.userId ?? config.userId) {
-    headers["X-User-Id"] = options?.userId ?? config.userId ?? "";
-  }
-  if (options?.organizationId ?? config.organizationId) {
-    headers["X-Organization-Id"] = options?.organizationId ?? config.organizationId ?? "";
-  }
-  if (finalClient) {
-    headers["X-Athena-Client"] = finalClient;
-  }
-  const finalBackend = options?.backend ?? config.backend;
-  if (finalBackend) {
-    const type = typeof finalBackend === "string" ? finalBackend : finalBackend.type;
-    if (type) headers["X-Backend-Type"] = type;
-  }
-  if (typeof mergedStripNulls === "boolean") {
-    headers["X-Strip-Nulls"] = mergedStripNulls ? "true" : "false";
-  }
-  if (finalPublishEvent) {
-    headers["X-Publish-Event"] = finalPublishEvent;
-  }
-  if (finalApiKey) {
-    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;
-    if (forceNoCache && isCacheControlHeaderName(key)) return;
-    const normalized = normalizeHeaderValue(value);
-    if (normalized) {
-      headers[key] = normalized;
-    }
+  return buildServiceRequestHeaders("gateway", SDK_HEADER_VALUE, config, options, {
+    client: options?.client ?? config.client ?? DEFAULT_CLIENT,
+    stripNulls: options?.stripNulls ?? true
   });
-  if (forceNoCache) {
-    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE;
-  }
-  return headers;
 }
 function toInvalidUrlResponse(error, endpoint, method) {
   const message = error instanceof Error ? error.message : String(error);