@xylex-group/athena 1.0.2 → 1.1.0

package/dist/index.d.cts

@@ -0,0 +1,84 @@
+import { B as BackendConfig, a as BackendType, A as AthenaConditionValue, b as AthenaConditionArrayValue, c as AthenaConditionOperator, d as AthenaGatewayCallOptions } from './types-IHkO67Tl.cjs';
+export { e as Backend } from './types-IHkO67Tl.cjs';
+
+interface SupabaseResult<T> {
+    data: T | null;
+    error: string | null;
+    status: number;
+    raw: unknown;
+}
+type MutationSingleResult<Result> = Result extends Array<infer Item> ? Item | null : Result | null;
+interface MutationQuery<Result> extends PromiseLike<SupabaseResult<Result>> {
+    select(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<Result>>;
+    returning(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<Result>>;
+    single(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<MutationSingleResult<Result>>>;
+    maybeSingle(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<MutationSingleResult<Result>>>;
+    then<TResult1 = SupabaseResult<Result>, TResult2 = never>(onfulfilled?: ((value: SupabaseResult<Result>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<SupabaseResult<Result> | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<SupabaseResult<Result>>;
+}
+/** Shared filter chain - supports eq, limit, etc. in any order relative to select/update */
+interface FilterChain<Self> {
+    eq(column: string, value: AthenaConditionValue): Self;
+    match(filters: Record<string, AthenaConditionValue>): Self;
+    range(from: number, to: number): Self;
+    limit(count: number): Self;
+    offset(count: number): Self;
+    gt(column: string, value: AthenaConditionValue): Self;
+    gte(column: string, value: AthenaConditionValue): Self;
+    lt(column: string, value: AthenaConditionValue): Self;
+    lte(column: string, value: AthenaConditionValue): Self;
+    neq(column: string, value: AthenaConditionValue): Self;
+    like(column: string, value: AthenaConditionValue): Self;
+    ilike(column: string, value: AthenaConditionValue): Self;
+    is(column: string, value: AthenaConditionValue): Self;
+    in(column: string, values: AthenaConditionArrayValue): Self;
+    contains(column: string, values: AthenaConditionArrayValue): Self;
+    containedBy(column: string, values: AthenaConditionArrayValue): Self;
+    not(columnOrExpression: string, operator?: AthenaConditionOperator, value?: AthenaConditionValue): Self;
+    or(expression: string): Self;
+}
+/** Chain returned by select() - supports filters and single/maybeSingle before execution */
+interface SelectChain<Row> extends FilterChain<SelectChain<Row>>, PromiseLike<SupabaseResult<Row[]>> {
+    single<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<T | null>>;
+    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<T | null>>;
+}
+/** Chain returned by update() - supports filters before execution, plus select/returning */
+interface UpdateChain<Row> extends FilterChain<UpdateChain<Row>>, MutationQuery<Row[]> {
+}
+interface TableQueryBuilder<Row> extends FilterChain<TableQueryBuilder<Row>> {
+    select<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): SelectChain<T>;
+    insert(values: Row | Row[], options?: AthenaGatewayCallOptions): MutationQuery<Row | Row[]>;
+    upsert(values: Row | Row[], options?: AthenaGatewayCallOptions & {
+        updateBody?: Partial<Row>;
+        onConflict?: string | string[];
+    }): MutationQuery<Row | Row[]>;
+    update(values: Partial<Row>, options?: AthenaGatewayCallOptions): UpdateChain<Row>;
+    delete(options?: AthenaGatewayCallOptions & {
+        resourceId?: string;
+    }): MutationQuery<Row | null>;
+    single<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<T | null>>;
+    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<T | null>>;
+    reset(): TableQueryBuilder<Row>;
+}
+interface SupabaseClient {
+    from<Row = unknown>(table: string): TableQueryBuilder<Row>;
+}
+interface AthenaClientBuilder {
+    url(url: string): AthenaClientBuilder;
+    key(apiKey: string): AthenaClientBuilder;
+    backend(backend: BackendConfig | BackendType): AthenaClientBuilder;
+    client(clientName: string): AthenaClientBuilder;
+    headers(headers: Record<string, string>): AthenaClientBuilder;
+    healthTracking(enabled: boolean): AthenaClientBuilder;
+    build(): SupabaseClient;
+}
+declare const AthenaClient: {
+    builder(): AthenaClientBuilder;
+    /** Build client from env: ATHENA_SUPABASE_URL, ATHENA_SUPABASE_KEY (or SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY) */
+    fromSupabaseEnv(): SupabaseClient;
+};
+/** Create client (convenience wrapper; use AthenaClient.builder() for full control) */
+declare function createClient(url: string, apiKey: string, options?: Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'>): SupabaseClient;
+
+export { AthenaClient, AthenaGatewayCallOptions, BackendConfig, BackendType, type SupabaseClient, type SupabaseResult, type TableQueryBuilder, createClient };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { A as AthenaGatewayCallOptions, a as AthenaConditionValue, b as AthenaConditionArrayValue, c as AthenaConditionOperator } from './types-DzCf3v76.js';
-export { d as AthenaDeletePayload, e as AthenaFetchPayload, f as AthenaGatewayBaseOptions, g as AthenaGatewayCallLog, h as AthenaGatewayCondition, i as AthenaGatewayEndpointPath, j as AthenaGatewayHookConfig, k as AthenaGatewayHookResult, l as AthenaGatewayMethod, m as AthenaGatewayResponse, n as AthenaGatewayResponseLog, o as AthenaInsertPayload, p as AthenaUpdatePayload } from './types-DzCf3v76.js';
+import { B as BackendConfig, a as BackendType, A as AthenaConditionValue, b as AthenaConditionArrayValue, c as AthenaConditionOperator, d as AthenaGatewayCallOptions } from './types-IHkO67Tl.js';
+export { e as Backend } from './types-IHkO67Tl.js';
 
 interface SupabaseResult<T> {
     data: T | null;
@@ -17,35 +17,46 @@ interface MutationQuery<Result> extends PromiseLike<SupabaseResult<Result>> {
     catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<SupabaseResult<Result> | TResult>;
     finally(onfinally?: (() => void) | undefined | null): Promise<SupabaseResult<Result>>;
 }
-interface TableQueryBuilder<Row> {
-    select<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<T>>;
+/** Shared filter chain - supports eq, limit, etc. in any order relative to select/update */
+interface FilterChain<Self> {
+    eq(column: string, value: AthenaConditionValue): Self;
+    match(filters: Record<string, AthenaConditionValue>): Self;
+    range(from: number, to: number): Self;
+    limit(count: number): Self;
+    offset(count: number): Self;
+    gt(column: string, value: AthenaConditionValue): Self;
+    gte(column: string, value: AthenaConditionValue): Self;
+    lt(column: string, value: AthenaConditionValue): Self;
+    lte(column: string, value: AthenaConditionValue): Self;
+    neq(column: string, value: AthenaConditionValue): Self;
+    like(column: string, value: AthenaConditionValue): Self;
+    ilike(column: string, value: AthenaConditionValue): Self;
+    is(column: string, value: AthenaConditionValue): Self;
+    in(column: string, values: AthenaConditionArrayValue): Self;
+    contains(column: string, values: AthenaConditionArrayValue): Self;
+    containedBy(column: string, values: AthenaConditionArrayValue): Self;
+    not(columnOrExpression: string, operator?: AthenaConditionOperator, value?: AthenaConditionValue): Self;
+    or(expression: string): Self;
+}
+/** Chain returned by select() - supports filters and single/maybeSingle before execution */
+interface SelectChain<Row> extends FilterChain<SelectChain<Row>>, PromiseLike<SupabaseResult<Row[]>> {
+    single<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<T | null>>;
+    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<T | null>>;
+}
+/** Chain returned by update() - supports filters before execution, plus select/returning */
+interface UpdateChain<Row> extends FilterChain<UpdateChain<Row>>, MutationQuery<Row[]> {
+}
+interface TableQueryBuilder<Row> extends FilterChain<TableQueryBuilder<Row>> {
+    select<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): SelectChain<T>;
     insert(values: Row | Row[], options?: AthenaGatewayCallOptions): MutationQuery<Row | Row[]>;
     upsert(values: Row | Row[], options?: AthenaGatewayCallOptions & {
         updateBody?: Partial<Row>;
         onConflict?: string | string[];
     }): MutationQuery<Row | Row[]>;
-    update(values: Partial<Row>, options?: AthenaGatewayCallOptions): MutationQuery<Row[]>;
+    update(values: Partial<Row>, options?: AthenaGatewayCallOptions): UpdateChain<Row>;
     delete(options?: AthenaGatewayCallOptions & {
         resourceId?: string;
     }): MutationQuery<Row | null>;
-    eq(column: string, value: AthenaConditionValue): TableQueryBuilder<Row>;
-    match(filters: Record<string, AthenaConditionValue>): TableQueryBuilder<Row>;
-    range(from: number, to: number): TableQueryBuilder<Row>;
-    limit(count: number): TableQueryBuilder<Row>;
-    offset(count: number): TableQueryBuilder<Row>;
-    gt(column: string, value: AthenaConditionValue): TableQueryBuilder<Row>;
-    gte(column: string, value: AthenaConditionValue): TableQueryBuilder<Row>;
-    lt(column: string, value: AthenaConditionValue): TableQueryBuilder<Row>;
-    lte(column: string, value: AthenaConditionValue): TableQueryBuilder<Row>;
-    neq(column: string, value: AthenaConditionValue): TableQueryBuilder<Row>;
-    like(column: string, value: AthenaConditionValue): TableQueryBuilder<Row>;
-    ilike(column: string, value: AthenaConditionValue): TableQueryBuilder<Row>;
-    is(column: string, value: AthenaConditionValue): TableQueryBuilder<Row>;
-    in(column: string, values: AthenaConditionArrayValue): TableQueryBuilder<Row>;
-    contains(column: string, values: AthenaConditionArrayValue): TableQueryBuilder<Row>;
-    containedBy(column: string, values: AthenaConditionArrayValue): TableQueryBuilder<Row>;
-    not(columnOrExpression: string, operator?: AthenaConditionOperator, value?: AthenaConditionValue): TableQueryBuilder<Row>;
-    or(expression: string): TableQueryBuilder<Row>;
     single<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<T | null>>;
     maybeSingle<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<SupabaseResult<T | null>>;
     reset(): TableQueryBuilder<Row>;
@@ -53,6 +64,21 @@ interface TableQueryBuilder<Row> {
 interface SupabaseClient {
     from<Row = unknown>(table: string): TableQueryBuilder<Row>;
 }
-declare function createClient(url: string, apiKey: string, options?: AthenaGatewayCallOptions): SupabaseClient;
+interface AthenaClientBuilder {
+    url(url: string): AthenaClientBuilder;
+    key(apiKey: string): AthenaClientBuilder;
+    backend(backend: BackendConfig | BackendType): AthenaClientBuilder;
+    client(clientName: string): AthenaClientBuilder;
+    headers(headers: Record<string, string>): AthenaClientBuilder;
+    healthTracking(enabled: boolean): AthenaClientBuilder;
+    build(): SupabaseClient;
+}
+declare const AthenaClient: {
+    builder(): AthenaClientBuilder;
+    /** Build client from env: ATHENA_SUPABASE_URL, ATHENA_SUPABASE_KEY (or SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY) */
+    fromSupabaseEnv(): SupabaseClient;
+};
+/** Create client (convenience wrapper; use AthenaClient.builder() for full control) */
+declare function createClient(url: string, apiKey: string, options?: Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'>): SupabaseClient;
 
-export { AthenaGatewayCallOptions, type SupabaseClient, type SupabaseResult, type TableQueryBuilder, createClient };
+export { AthenaClient, AthenaGatewayCallOptions, BackendConfig, BackendType, type SupabaseClient, type SupabaseResult, type TableQueryBuilder, createClient };

package/dist/index.js

@@ -1,5 +1,3 @@
-'use strict';
-
 // src/gateway/client.ts
 var DEFAULT_BASE_URL = "https://athena-db.com";
 var DEFAULT_CLIENT = "railway_direct";
@@ -15,31 +13,32 @@ function normalizeHeaderValue(value) {
   return value ? value : void 0;
 }
 function buildHeaders(config, options) {
-  const mergedStripNulls = options?.stripNulls ?? config.stripNulls ?? true;
-  const finalClient = options?.client ?? config.client ?? DEFAULT_CLIENT;
-  const finalApiKey = options?.apiKey ?? config.apiKey;
-  const finalSupabaseUrl = options?.supabaseUrl ?? config.supabaseUrl;
-  const finalSupabaseKey = options?.supabaseKey ?? config.supabaseKey;
-  const finalPublishEvent = options?.publishEvent ?? config.publishEvent;
+  const mergedStripNulls = options?.stripNulls ?? true;
   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"
   };
   if (options?.userId ?? config.userId) {
     headers["X-User-Id"] = options?.userId ?? config.userId ?? "";
   }
-  if (options?.companyId ?? config.companyId) {
-    headers["X-Company-Id"] = options?.companyId ?? config.companyId ?? "";
-  }
   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";
   }
@@ -50,13 +49,9 @@ function buildHeaders(config, options) {
     headers["apikey"] = finalApiKey;
     headers["x-api-key"] = headers["x-api-key"] ?? finalApiKey;
   }
-  if (finalSupabaseUrl) {
-    headers["x-supabase-url"] = finalSupabaseUrl;
-  }
-  if (finalSupabaseKey) {
-    headers["x-supabase-key"] = finalSupabaseKey;
-  }
+  const athenaClientKeys = ["x-athena-client", "X-Athena-Client"];
   Object.entries(extraHeaders).forEach(([key, value]) => {
+    if (athenaClientKeys.includes(key)) return;
     const normalized = normalizeHeaderValue(value);
     if (normalized) {
       headers[key] = normalized;
@@ -196,115 +191,155 @@ function stringifyFilterValue(value) {
   }
   return String(value);
 }
-function createTableBuilder(tableName, client) {
-  const state = {
-    conditions: []
-  };
-  const addCondition = (operator, column, value) => {
-    const condition = { operator };
-    if (column) condition.column = column;
-    if (value !== void 0) condition.value = value;
-    state.conditions.push(condition);
-  };
-  const builder = {
-    reset() {
-      state.conditions = [];
-      state.limit = void 0;
-      state.offset = void 0;
-      return builder;
+function createFilterMethods(state, addCondition, self) {
+  return {
+    eq(column, value) {
+      addCondition("eq", column, value);
+      return self;
+    },
+    match(filters) {
+      Object.entries(filters).forEach(([column, value]) => addCondition("eq", column, value));
+      return self;
     },
     range(from, to) {
       state.offset = from;
       state.limit = to - from + 1;
-      return builder;
+      return self;
     },
     limit(count) {
       state.limit = count;
-      return builder;
+      return self;
     },
     offset(count) {
       state.offset = count;
-      return builder;
-    },
-    match(filters) {
-      Object.entries(filters).forEach(([column, value]) => {
-        addCondition("eq", column, value);
-      });
-      return builder;
-    },
-    eq(column, value) {
-      addCondition("eq", column, value);
-      return builder;
+      return self;
     },
     gt(column, value) {
       addCondition("gt", column, value);
-      return builder;
+      return self;
     },
     gte(column, value) {
       addCondition("gte", column, value);
-      return builder;
+      return self;
     },
     lt(column, value) {
       addCondition("lt", column, value);
-      return builder;
+      return self;
     },
     lte(column, value) {
       addCondition("lte", column, value);
-      return builder;
+      return self;
     },
     neq(column, value) {
       addCondition("neq", column, value);
-      return builder;
+      return self;
     },
     like(column, value) {
       addCondition("like", column, value);
-      return builder;
+      return self;
     },
     ilike(column, value) {
       addCondition("ilike", column, value);
-      return builder;
+      return self;
     },
     is(column, value) {
       addCondition("is", column, value);
-      return builder;
+      return self;
     },
     in(column, values) {
       addCondition("in", column, values);
-      return builder;
+      return self;
     },
     contains(column, values) {
       addCondition("contains", column, values);
-      return builder;
+      return self;
     },
     containedBy(column, values) {
       addCondition("containedBy", column, values);
-      return builder;
+      return self;
     },
     not(columnOrExpression, operator, value) {
-      if (operator && value !== void 0) {
+      if (operator != null && value !== void 0) {
         addCondition("not", void 0, `${columnOrExpression}.${operator}.${stringifyFilterValue(value)}`);
       } else {
         addCondition("not", void 0, columnOrExpression);
       }
-      return builder;
+      return self;
     },
     or(expression) {
       addCondition("or", void 0, expression);
+      return self;
+    }
+  };
+}
+function createTableBuilder(tableName, client) {
+  const state = {
+    conditions: []
+  };
+  const addCondition = (operator, column, value) => {
+    const condition = { operator };
+    if (column) {
+      condition.column = column;
+      if (operator === "eq") {
+        condition.eq_column = column;
+      }
+    }
+    if (value !== void 0) {
+      condition.value = value;
+      if (operator === "eq") {
+        condition.eq_value = value;
+      }
+    }
+    state.conditions.push(condition);
+  };
+  const builder = {};
+  const filterMethods = createFilterMethods(state, addCondition, builder);
+  const runSelect = async (columns = DEFAULT_COLUMNS, options) => {
+    const payload = {
+      table_name: tableName,
+      columns,
+      conditions: state.conditions.length ? [...state.conditions] : void 0,
+      limit: state.limit,
+      offset: state.offset,
+      strip_nulls: options?.stripNulls ?? true,
+      count: options?.count,
+      head: options?.head
+    };
+    const response = await client.fetchGateway(payload, options);
+    return formatResult(response);
+  };
+  const createSelectChain = (columns, options) => {
+    const chain = {};
+    const filterMethods2 = createFilterMethods(state, addCondition, chain);
+    Object.assign(chain, filterMethods2, {
+      async single(cols, opts) {
+        const r = await runSelect(cols ?? columns, opts ?? options);
+        return toSingleResult(r);
+      },
+      maybeSingle(cols, opts) {
+        return chain.single(cols, opts);
+      },
+      then(onfulfilled, onrejected) {
+        return runSelect(columns, options).then(onfulfilled, onrejected);
+      },
+      catch(onrejected) {
+        return runSelect(columns, options).catch(onrejected);
+      },
+      finally(onfinally) {
+        return runSelect(columns, options).finally(onfinally);
+      }
+    });
+    return chain;
+  };
+  Object.assign(builder, filterMethods, {
+    reset() {
+      state.conditions = [];
+      state.limit = void 0;
+      state.offset = void 0;
       return builder;
     },
-    async select(columns = DEFAULT_COLUMNS, options) {
-      const payload = {
-        table_name: tableName,
-        columns,
-        conditions: state.conditions.length ? [...state.conditions] : void 0,
-        limit: state.limit,
-        offset: state.offset,
-        strip_nulls: options?.stripNulls ?? true,
-        count: options?.count,
-        head: options?.head
-      };
-      const response = await client.fetchGateway(payload, options);
-      return formatResult(response);
+    select(columns = DEFAULT_COLUMNS, options) {
+      return createSelectChain(columns, options);
     },
     insert(values, options) {
       const executeInsert = async (columns, selectOptions) => {
@@ -345,8 +380,8 @@ function createTableBuilder(tableName, client) {
       return createMutationQuery(executeUpsert);
     },
     update(values, options) {
-      const filters = state.conditions.length ? [...state.conditions] : void 0;
       const executeUpdate = async (columns, selectOptions) => {
+        const filters = state.conditions.length ? [...state.conditions] : void 0;
         const mergedOptions = mergeOptions(options, selectOptions);
         const payload = {
           table_name: tableName,
@@ -358,7 +393,11 @@ function createTableBuilder(tableName, client) {
         const response = await client.updateGateway(payload, mergedOptions);
         return formatResult(response);
       };
-      return createMutationQuery(executeUpdate);
+      const mutation = createMutationQuery(executeUpdate);
+      const updateChain = {};
+      const filterMethods2 = createFilterMethods(state, addCondition, updateChain);
+      Object.assign(updateChain, filterMethods2, mutation);
+      return updateChain;
     },
     delete(options) {
       const filters = state.conditions.length ? [...state.conditions] : void 0;
@@ -386,23 +425,101 @@ function createTableBuilder(tableName, client) {
     async maybeSingle(columns, options) {
       return builder.single(columns, options);
     }
-  };
+  });
   return builder;
 }
-function createClient(url, apiKey, options) {
-  const { baseUrl: optBaseUrl, apiKey: optApiKey, ...restOptions } = options ?? {};
-  const client = createAthenaGatewayClient({
-    baseUrl: optBaseUrl ?? url,
-    apiKey: optApiKey ?? apiKey,
-    ...restOptions
+function createClientFromConfig(config) {
+  const gateway = createAthenaGatewayClient({
+    baseUrl: config.baseUrl,
+    apiKey: config.apiKey,
+    client: config.client,
+    backend: config.backend,
+    headers: config.headers
   });
   return {
     from(table) {
-      return createTableBuilder(table, client);
+      return createTableBuilder(table, gateway);
     }
   };
 }
+var DEFAULT_BACKEND = { type: "athena" };
+function toBackendConfig(b) {
+  if (!b) return DEFAULT_BACKEND;
+  return typeof b === "string" ? { type: b } : b;
+}
+var AthenaClient = {
+  builder() {
+    let url;
+    let key;
+    let backend = DEFAULT_BACKEND;
+    let clientName;
+    let headers;
+    const builder = {
+      url(u) {
+        url = u;
+        return builder;
+      },
+      key(k) {
+        key = k;
+        return builder;
+      },
+      backend(b) {
+        backend = toBackendConfig(b);
+        return builder;
+      },
+      client(c) {
+        clientName = c;
+        return builder;
+      },
+      headers(h) {
+        headers = h;
+        return builder;
+      },
+      healthTracking(enabled) {
+        return builder;
+      },
+      build() {
+        if (!url || !key) {
+          throw new Error("AthenaClient requires url and key; call .url() and .key() before .build()");
+        }
+        return createClientFromConfig({
+          baseUrl: url,
+          apiKey: key,
+          client: clientName,
+          backend,
+          headers});
+      }
+    };
+    return builder;
+  },
+  /** Build client from env: ATHENA_SUPABASE_URL, ATHENA_SUPABASE_KEY (or SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY) */
+  fromSupabaseEnv() {
+    const url = process.env.ATHENA_SUPABASE_URL ?? process.env.SUPABASE_URL;
+    const key = process.env.ATHENA_SUPABASE_KEY ?? process.env.SUPABASE_SERVICE_ROLE_KEY;
+    if (!url || !key) {
+      throw new Error(
+        "ATHENA_SUPABASE_URL and ATHENA_SUPABASE_KEY (or SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY) are required"
+      );
+    }
+    return AthenaClient.builder().backend({ type: "supabase" }).url(url).key(key).build();
+  }
+};
+function createClient(url, apiKey, options) {
+  const b = AthenaClient.builder().url(url).key(apiKey).backend(toBackendConfig(options?.backend));
+  if (options?.client) b.client(options.client);
+  if (options?.headers && Object.keys(options.headers).length > 0) b.headers(options.headers);
+  return b.build();
+}
+
+// src/gateway/types.ts
+var Backend = {
+  Athena: { type: "athena" },
+  Supabase: { type: "supabase" },
+  Postgrest: { type: "postgrest" },
+  PostgreSQL: { type: "postgresql" },
+  ScyllaDB: { type: "scylladb" }
+};
 
-exports.createClient = createClient;
+export { AthenaClient, Backend, createClient };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map