@xylex-group/athena 1.1.2 → 1.2.0

package/dist/index.d.ts

@@ -1,21 +1,23 @@
-import { B as BackendConfig, a as BackendType, A as AthenaConditionValue, b as AthenaConditionArrayValue, c as AthenaConditionOperator, d as AthenaGatewayCallOptions } from './types-DorEXMAz.js';
-export { e as Backend } from './types-DorEXMAz.js';
+import { B as BackendConfig, a as BackendType, A as AthenaConditionValue, b as AthenaConditionArrayValue, c as AthenaConditionOperator, d as AthenaGatewayCallOptions, e as AthenaGatewayErrorDetails, f as AthenaRpcCallOptions } from './errors-DKNcLa5O.js';
+export { g as AthenaGatewayError, h as AthenaGatewayErrorCode, i as AthenaRpcFilter, j as AthenaRpcFilterOperator, k as AthenaRpcOrder, l as AthenaRpcPayload, m as Backend, n as isAthenaGatewayError } from './errors-DKNcLa5O.js';
 
-interface SupabaseResult<T> {
+interface AthenaResult<T> {
     data: T | null;
     error: string | null;
+    errorDetails?: AthenaGatewayErrorDetails | null;
     status: number;
+    count?: number | null;
     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>>;
+interface MutationQuery<Result> extends PromiseLike<AthenaResult<Result>> {
+    select(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
+    returning(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
+    single(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
+    maybeSingle(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
+    then<TResult1 = AthenaResult<Result>, TResult2 = never>(onfulfilled?: ((value: AthenaResult<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<AthenaResult<Result> | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<AthenaResult<Result>>;
 }
 /** Shared filter chain - supports eq, limit, etc. in any order relative to select/update */
 interface FilterChain<Self> {
@@ -39,13 +41,37 @@ interface FilterChain<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>>;
+interface SelectChain<Row> extends FilterChain<SelectChain<Row>>, PromiseLike<AthenaResult<Row[]>> {
+    single<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
 }
 /** Chain returned by update() - supports filters before execution, plus select/returning */
 interface UpdateChain<Row> extends FilterChain<UpdateChain<Row>>, MutationQuery<Row[]> {
 }
+interface RpcFilterChain<Self> {
+    eq(column: string, value: AthenaConditionValue): Self;
+    neq(column: string, value: AthenaConditionValue): 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;
+    like(column: string, value: AthenaConditionValue): Self;
+    ilike(column: string, value: AthenaConditionValue): Self;
+    is(column: string, value: AthenaConditionValue): Self;
+    in(column: string, values: AthenaConditionArrayValue): Self;
+}
+interface RpcOrderOptions {
+    ascending?: boolean;
+}
+interface RpcQueryBuilder<Row> extends RpcFilterChain<RpcQueryBuilder<Row>>, PromiseLike<AthenaResult<Row[]>> {
+    select(columns?: string | string[], options?: AthenaRpcCallOptions): Promise<AthenaResult<Row[]>>;
+    single<T = Row>(columns?: string | string[], options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
+    order(column: string, options?: RpcOrderOptions): RpcQueryBuilder<Row>;
+    limit(count: number): RpcQueryBuilder<Row>;
+    offset(count: number): RpcQueryBuilder<Row>;
+    range(from: number, to: number): RpcQueryBuilder<Row>;
+}
 interface TableQueryBuilder<Row> extends FilterChain<TableQueryBuilder<Row>> {
     select<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): SelectChain<T>;
     insert(values: Row, options?: AthenaGatewayCallOptions): MutationQuery<Row>;
@@ -62,28 +88,39 @@ interface TableQueryBuilder<Row> extends FilterChain<TableQueryBuilder<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>>;
+    single<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
     reset(): TableQueryBuilder<Row>;
 }
-interface SupabaseClient {
+interface AthenaSdkClient {
     from<Row = unknown>(table: string): TableQueryBuilder<Row>;
+    rpc<Row = unknown, Args extends Record<string, unknown> = Record<string, unknown>>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row>;
+    query<Row = unknown>(query: string, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Row[]>>;
 }
 interface AthenaClientBuilder {
+    /** Set the gateway base URL. */
     url(url: string): AthenaClientBuilder;
+    /** Set the API key used for all requests. */
     key(apiKey: string): AthenaClientBuilder;
+    /** Set the default backend routing strategy. */
     backend(backend: BackendConfig | BackendType): AthenaClientBuilder;
+    /** Set the default Athena client routing key. */
     client(clientName: string): AthenaClientBuilder;
+    /** Attach static headers to every request. */
     headers(headers: Record<string, string>): AthenaClientBuilder;
+    /** Enable or disable health tracking metadata. */
     healthTracking(enabled: boolean): AthenaClientBuilder;
-    build(): SupabaseClient;
+    /** Build the immutable Athena SDK client. */
+    build(): AthenaSdkClient;
+}
+/** Canonical Athena client factory with builder-based configuration. */
+declare class AthenaClient {
+    /** Create a fluent builder for a strongly-typed Athena SDK client. */
+    static builder(): AthenaClientBuilder;
+    /** Build a client from process environment variables. */
+    static fromEnvironment(): AthenaSdkClient;
 }
-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;
+declare function createClient(url: string, apiKey: string, options?: Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'>): AthenaSdkClient;
 
-export { AthenaClient, AthenaGatewayCallOptions, BackendConfig, BackendType, type SupabaseClient, type SupabaseResult, type TableQueryBuilder, createClient };
+export { AthenaClient, AthenaGatewayCallOptions, AthenaGatewayErrorDetails, type AthenaResult, AthenaRpcCallOptions, type AthenaSdkClient, BackendConfig, BackendType, type RpcOrderOptions, type RpcQueryBuilder, type TableQueryBuilder, createClient };