Client Configuration

/**
 * Creates a PostgREST client
 * @param url - URL of the PostgREST endpoint
 * @param options - Named parameters
 * @param options.headers - Custom headers
 * @param options.schema - Postgres schema to switch to
 * @param options.fetch - Custom fetch implementation
 */
class PostgrestClient<
  Database = any,
  ClientOptions extends ClientServerOptions = {},
  SchemaName extends string = 'public',
  Schema extends GenericSchema = any
> {
  constructor(
    url: string,
    options?: {
      headers?: HeadersInit;
      schema?: SchemaName;
      fetch?: Fetch;
    }
  );
  
  // Properties
  url: string;
  headers: Headers;
  schemaName?: SchemaName;
  fetch?: Fetch;
}

import { PostgrestClient } from "@supabase/postgrest-js";

// Basic client
const client = new PostgrestClient("https://api.example.com");

// Client with custom headers
const clientWithAuth = new PostgrestClient("https://api.example.com", {
  headers: {
    'Authorization': 'Bearer your-token',
    'X-Custom-Header': 'value'
  }
});

// Client with specific schema
const publicClient = new PostgrestClient("https://api.example.com", {
  schema: "public"
});

// Client with custom fetch (Node.js with specific options)
const nodeClient = new PostgrestClient("https://api.example.com", {
  fetch: (url, options) => fetch(url, {
    ...options,
    timeout: 30000,
    agent: myCustomAgent
  })
});

/**
 * Select a schema to query or perform an function (rpc) call.
 * The schema needs to be on the list of exposed schemas inside Supabase.
 * @param schema - The schema to query
 */
schema<DynamicSchema extends string & keyof Database>(
  schema: DynamicSchema
): PostgrestClient<Database, ClientOptions, DynamicSchema, Database[DynamicSchema]>;

const client = new PostgrestClient("https://api.example.com");

// Switch to private schema
const privateClient = client.schema("private");

// Query from private schema
const { data } = await privateClient
  .from("private_table")
  .select("*");

// Switch back to public schema
const publicClient = client.schema("public");

/**
 * Perform a query on a table or a view
 * @param relation - The table or view name to query
 */
from<TableName extends string & keyof Schema['Tables']>(
  relation: TableName
): PostgrestQueryBuilder<ClientOptions, Schema, Schema['Tables'][TableName], TableName>;

from<ViewName extends string & keyof Schema['Views']>(
  relation: ViewName
): PostgrestQueryBuilder<ClientOptions, Schema, Schema['Views'][ViewName], ViewName>;

from(relation: string): PostgrestQueryBuilder<ClientOptions, Schema, any, any>;

const client = new PostgrestClient("https://api.example.com");

// Query a table
const usersQuery = client.from("users");

// Query a view
const activeUsersQuery = client.from("active_users_view");

// Chain immediately
const { data } = await client
  .from("products")
  .select("name, price")
  .eq("category", "electronics");

/**
 * Set an HTTP header for the request
 * @param name - Header name
 * @param value - Header value
 */
setHeader(name: string, value: string): this;

// Set headers during client construction
const client = new PostgrestClient("https://api.example.com", {
  headers: {
    'Authorization': 'Bearer token',
    'X-API-Key': 'your-api-key'
  }
});

// Set headers on individual queries
const { data } = await client
  .from("users")
  .select("*")
  .setHeader("X-Request-ID", "unique-request-id");

type Fetch = typeof fetch;

import fetch from 'node-fetch';
import { PostgrestClient } from "@supabase/postgrest-js";

// Node.js with node-fetch
const client = new PostgrestClient("https://api.example.com", {
  fetch: fetch as any
});

// Custom fetch with timeout
const customFetch = (url: string, options: RequestInit) => {
  return fetch(url, {
    ...options,
    timeout: 10000 // 10 second timeout
  });
};

const clientWithTimeout = new PostgrestClient("https://api.example.com", {
  fetch: customFetch
});

// Fetch with custom user agent
const clientWithUA = new PostgrestClient("https://api.example.com", {
  fetch: (url, options) => fetch(url, {
    ...options,
    headers: {
      ...options?.headers,
      'User-Agent': 'MyApp/1.0.0'
    }
  })
});

// With typed database schema
interface Database {
  public: {
    Tables: {
      users: {
        Row: { id: number; name: string; email: string };
        Insert: { name: string; email: string };
        Update: { name?: string; email?: string };
      };
    };
    Views: {
      active_users: {
        Row: { id: number; name: string; last_active: string };
      };
    };
    Functions: {
      get_user_stats: {
        Args: { user_id: number };
        Returns: { total_posts: number; total_likes: number };
      };
    };
  };
}

const typedClient = new PostgrestClient<Database>("https://api.example.com");

// Full type safety for table queries
const users = await typedClient
  .from("users") // ✅ Type-safe table name
  .select("id, name, email") // ✅ Type-safe column names
  .eq("id", 123); // ✅ Type-safe filtering

// Type inference for results
// users.data will be of type: { id: number; name: string; email: string }[] | null