Esta versão (v0.7) ainda não foi publicada no npm.
Pular para o conteúdo

Sem adapter (Svelte, Solid, Angular) ​

Não há adapter de Svelte, Solid ou Angular (para Vue 3 existe o @getenginex/sdk-vue, que faz tudo o que esta página descreve). As fábricas de @getenginex/sdk/query (e dos /query dos pacotes de produto) devolvem objetos simples, compatíveis com o TanStack Query v5 de qualquer framework:

ts
import { createMutations, createQueries, enginexKeys } from '@getenginex/sdk/query'

const q = createQueries(enginex)   // once per client
const m = createMutations(enginex)

q.wallet.getBalance()      // { queryKey, queryFn }  → useQuery / createQuery / prefetchQuery
m.deposits.createPix()     // { mutationKey, mutationFn, invalidates }  → useMutation / createMutation

As chaves, a invalidação e a idempotência são as da camada de queries.

O que os adapters (React e Vue) fazem e você faz à mão ​

  1. Chamar a fábrica de novo quando a sessão muda. A chave das queries de usuário leva o userId da hora da chamada (sem sessão, 'anonymous', e o queryFn rejeita com UNAUTHENTICATED sem request). Monte as opções dentro de algo reativo à sessão (um getter, computed, $derived, signal) para a chave acompanhar login e logout.
  2. Remover os dados do usuário anterior. Quando o usuário muda, remova (não só invalide) enginexKeys.user() do QueryClient.
  3. Invalidar depois do sucesso. No onSuccess, invalide cada chave de invalidates(input, result) e devolva a promise, para a mutation só terminar com os dados atualizados.
  4. Não repetir UNAUTHENTICATED. Esse erro não fez request; repeti-lo só atrasa o erro.

Os passos 2 e 4 cabem num módulo só, compartilhado pelos exemplos abaixo:

ts
// enginex.ts
import { createEnginexClient, isEnginexError, localStorageTokenStore, type Session } from '@getenginex/sdk'
import { createMutations, createQueries, enginexKeys } from '@getenginex/sdk/query'
// The framework package's QueryClient.
import { QueryClient } from '@tanstack/svelte-query' // or '@tanstack/solid-query'

export const enginex = createEnginexClient({ locale: 'pt-BR', tokenStore: localStorageTokenStore() })
export const q = createQueries(enginex)
export const m = createMutations(enginex)

export const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 60_000,
      retry: (failures, error) => !isEnginexError(error, 'UNAUTHENTICATED') && failures < 3,
    },
  },
})

// User switch (logout, login, another `sub`): nothing from the previous player stays in the cache.
const identity = (s: Session) => `${s.status}:${s.userId ?? ''}`
let last = identity(enginex.session.get())
enginex.session.subscribe((session) => {
  const next = identity(session)
  if (next !== last) queryClient.removeQueries({ queryKey: enginexKeys.user() })
  last = next
})

// Step 3: the onSuccess of every SDK mutation.
export function invalidateAfter<I, R>(options: { invalidates: (input: I, result: R) => readonly (readonly unknown[])[] }) {
  return (result: R, input: I) =>
    Promise.all(options.invalidates(input, result).map((queryKey) => queryClient.invalidateQueries({ queryKey })))
}

Svelte 5 (@tanstack/svelte-query 6) ​

svelte
<!-- App.svelte -->
<script lang="ts">
  import { QueryClientProvider } from '@tanstack/svelte-query'
  import { queryClient } from './enginex'
  let { children } = $props()
</script>

<QueryClientProvider client={queryClient}>{@render children()}</QueryClientProvider>
ts
// session.svelte.ts
import { enginex } from './enginex'

class SessionState {
  current = $state.raw(enginex.session.get())
}
export const session = new SessionState()
enginex.session.subscribe((s) => {
  session.current = s
})
svelte
<script lang="ts">
  import { createMutation, createQuery } from '@tanstack/svelte-query'
  import { invalidateAfter, m, q } from './enginex'
  import { session } from './session.svelte'

  // The function is re-evaluated when `session.current` changes: the key follows the login.
  const balance = createQuery(() => ({
    ...q.wallet.getBalance(),
    enabled: session.current.status === 'authenticated',
  }))

  const createPix = m.deposits.createPix()
  const pix = createMutation(() => ({ ...createPix, onSuccess: invalidateAfter(createPix) }))
</script>

{#if balance.data}<p>{balance.data.realBalance}</p>{/if}
<button disabled={pix.isPending} onclick={() => pix.mutate({ amount: 5000 })}>Deposit</button>

Esta página não tem exemplo de Svelte 4. Lá, com o @tanstack/svelte-query 5, as opções vão num store (derived do store da sessão) em vez de uma função; as regras acima são as mesmas.

Solid (@tanstack/solid-query) ​

tsx
import { QueryClientProvider, createMutation, createQuery } from '@tanstack/solid-query'
import { createSignal } from 'solid-js'
import { enginex, invalidateAfter, m, q, queryClient } from './enginex'

const [session, setSession] = createSignal(enginex.session.get())
enginex.session.subscribe(setSession)

function Wallet() {
  // The function is re-run when `session()` changes: the key follows the login.
  const balance = createQuery(() => ({
    ...q.wallet.getBalance(),
    enabled: session().status === 'authenticated',
  }))

  const createPix = m.deposits.createPix()
  const pix = createMutation(() => ({ ...createPix, onSuccess: invalidateAfter(createPix) }))

  return (
    <>
      <p>{balance.data?.realBalance}</p>
      <button disabled={pix.isPending} onClick={() => pix.mutate({ amount: 5000 })}>
        Deposit
      </button>
    </>
  )
}

export const App = () => (
  <QueryClientProvider client={queryClient}>
    <Wallet />
  </QueryClientProvider>
)

Sem framework (@tanstack/query-core) ​

As mesmas fábricas servem para o QueryClient puro, num script ou num servidor:

ts
const balance = await queryClient.fetchQuery(q.wallet.getBalance())
await queryClient.prefetchQuery(q.config.get())

No servidor, crie um client do SDK e um QueryClient por request (veja Primeiros passos), nunca em escopo de módulo.

Realtime ​

O realtime do core funciona igual em qualquer framework. Para o padrão do useRealtimeSync do React e do Vue (invalidar o saldo a cada balance_update em vez de escrever no cache), assine o tópico e invalide a chave da fábrica:

ts
import { coreTopics, createRealtime } from '@getenginex/sdk/realtime'

const realtime = createRealtime(enginex)
const invalidateBalance = () => queryClient.invalidateQueries({ queryKey: q.wallet.getBalance().queryKey })
const off = realtime.subscribe(coreTopics.balance(), invalidateBalance)
const offResync = realtime.onResync(coreTopics.balance(), invalidateBalance)

Assine só com um usuário na sessão e assine de novo quando o usuário mudar (a chave do saldo leva o userId). Veja Realtime.