HTTP

HttpClientFactory

Factory centrale per creare client HTTP preconfigurati. Espone createFetchClient, createAxiosClient, createJwtClient, createCookieClient, createPublicClient, getDefaultHttpClient e createHttpClient.

Quando usarlo

HttpClientFactory è il punto d'ingresso consigliato per creare istanze di IHttpClient: incapsula la scelta tra Fetch e Axios, applica i default sensati (timeout, Content-Type, Accept) e configura automaticamente la strategia di autenticazione richiesta.

Usa la factory invece di istanziare direttamente FetchHttpClient / AxiosHttpClient quando non hai requisiti particolari: ottieni configurazione coerente e fallback automatici.

`HttpClientType`

Enum per la funzione utility createHttpClient.

enum HttpClientType {
  FETCH = 'fetch',  // Default: zero dipendenze
  AXIOS = 'axios',  // Richiede axios installato
}

API factory

`createFetchClient`

static createFetchClient(
  baseConfig?: AxiosRequestConfig,
  options?: { withDefaultAuth?: boolean }
): IHttpClient

Crea un FetchHttpClient. Se withDefaultAuth: true, applica AuthStrategyFactory.createJwtStrategy().

import { HttpClientFactory } from '@pzeta/postgrest'

const client = HttpClientFactory.createFetchClient(
  { baseURL: 'https://api.example.com', timeout: 10000 },
  { withDefaultAuth: true }
)

`createAxiosClient`

static createAxiosClient(
  baseConfig?: AxiosRequestConfig,
  options?: { withDefaultAuth?: boolean }
): Promise<IHttpClient>

Crea un AxiosHttpClient. Asincrono: importa axios in lazy. Se withDefaultAuth: true, configura un AuthService con IAuthHandler legacy + strategia JWT.

const client = await HttpClientFactory.createAxiosClient({
  baseURL: 'https://api.example.com',
})

`createAuthClient`

static createAuthClient(baseConfig?: AxiosRequestConfig): IHttpClient

Client senza credenziali automatiche (withCredentials: false), pensato per endpoint di login/logout dove username e password vengono inviati esplicitamente.

const authClient = HttpClientFactory.createAuthClient({
  baseURL: 'https://auth.example.com',
})

await authClient.post('/login', { username: 'user', password: 'pwd' })

`createWithAuthStrategy`

static createWithAuthStrategy(
  strategyOrType: IAuthStrategy | AuthStrategyType,
  baseConfig?: AxiosRequestConfig
): IHttpClient

Crea un FetchHttpClient con una strategia di autenticazione specifica. Accetta sia un tipo (AuthStrategyType.JWT / COOKIE / NONE) che un'istanza IAuthStrategy già costruita.

import { AuthStrategyType, HttpClientFactory } from '@pzeta/postgrest'

const jwtClient = HttpClientFactory.createWithAuthStrategy(
  AuthStrategyType.JWT,
  { baseURL: 'https://api.example.com' }
)

Applica default: timeout: 10000, Content-Type: application/json, Accept: application/json (sovrascrivibili da baseConfig).

`createJwtClient`

static createJwtClient(baseConfig?: AxiosRequestConfig): IHttpClient

Shortcut per createWithAuthStrategy(AuthStrategyType.JWT, ...). Aggiunge Authorization: Bearer <token> su ogni richiesta; token salvato in sessionStorage di default.

const client = HttpClientFactory.createJwtClient({
  baseURL: 'https://api.example.com',
})

const users = await client.get<User[]>('/users')

`createCookieClient`

static createCookieClient(baseConfig?: AxiosRequestConfig): IHttpClient

Shortcut per createWithAuthStrategy(AuthStrategyType.COOKIE, ...). Imposta withCredentials: true: il browser invia automaticamente i session cookie HTTP-only.

const client = HttpClientFactory.createCookieClient({
  baseURL: 'https://api.example.com',
})

`createPublicClient`

static createPublicClient(baseConfig?: AxiosRequestConfig): IHttpClient

Shortcut per createWithAuthStrategy(AuthStrategyType.NONE, ...). Nessun header di autenticazione. Per endpoint pubblici.

const publicClient = HttpClientFactory.createPublicClient({
  baseURL: 'https://api.example.com',
})

const products = await publicClient.get('/public/products')

Funzioni standalone

`getDefaultHttpClient`

function getDefaultHttpClient(): IHttpClient

Singleton lazy-initialized del client di default. Configurato con:

FetchHttpClient
timeout: 10000
Headers: Content-Type: application/json, Accept: application/json
withCredentials: false
withDefaultAuth: true (strategia JWT)

import { getDefaultHttpClient } from '@pzeta/postgrest'

const client = getDefaultHttpClient()

// Nota: nessun baseURL configurato — fornire URL assoluti
const users = await client.get('https://api.example.com/users')

Nessun baseURL di default: in scenari multi-tenant o multi-API, fornisci l'URL completo nella richiesta o usa PostgRESTClient come facade configurata.

`createHttpClient`

async function createHttpClient(
  type: HttpClientType = HttpClientType.FETCH,
  config?: AxiosRequestConfig,
  authStrategy?: IAuthStrategy
): Promise<IHttpClient>

Funzione utility che applica i default (timeout, content-type) e crea il client del tipo richiesto. Se type = AXIOS ma axios non è disponibile, fallback automatico su Fetch (logga un warning).

import { createHttpClient, HttpClientType, AuthStrategyFactory } from '@pzeta/postgrest'

// Fetch (default)
const fetchClient = await createHttpClient()

// Axios con strategia JWT
const axiosClient = await createHttpClient(
  HttpClientType.AXIOS,
  { baseURL: 'https://api.example.com' },
  AuthStrategyFactory.createJwtStrategy()
)

Tabella decisionale

Caso d'uso	Metodo consigliato
Setup nuovo, JWT, browser	`createJwtClient`
Session cookie HTTP-only	`createCookieClient`
Endpoint pubblici / pre-login	`createPublicClient`
Login/logout explicit credentials	`createAuthClient`
Strategia custom o switch a runtime	`createWithAuthStrategy(strategyInstance, ...)`
Forzare Axios (interceptors esistenti)	`createAxiosClient`
Singleton condiviso senza configurazione esplicita	`getDefaultHttpClient`
Selezione runtime FETCH vs AXIOS	`createHttpClient(type, ...)`

Tipi correlati

FetchHttpClient

Client HTTP zero-dipendenze basato su Fetch API nativa. Compatibile con interfaccia Axios tramite FetchAdapter. Supporta auth strategy, retry su 401 e timeout.

StrategyAwareHttpClient

Client HTTP basato su Axios che integra IAuthStrategy moderna mantenendo backward compatibility con IAuthHandler legacy.