SDK JavaScript (@auris/js)

npm install @auris/js

pnpm add @auris/js

yarn add @auris/js

import { AurisClient } from '@auris/js'
 
const auris = new AurisClient({
  domain: 'auth.tuodominio.com',  // Dominio del tenant Auris (obbligatorio)
  clientId: 'app_xxxxx',          // Client ID dell'applicazione dalla Console (obbligatorio)
  redirectUri: 'http://localhost:3000/callback', // Deve corrispondere a un Callback URL registrato (obbligatorio per i flussi PKCE)
  tenant: 'my-tenant',            // Identificativo tenant inviato come header x-tenant (opzionale)
  storage: 'localStorage',        // Archiviazione token: 'localStorage' | 'sessionStorage' | 'memory' | istanza TokenStore
  autoRefresh: true,              // Aggiorna automaticamente i token di accesso prima della scadenza (default: true)
  scope: 'openid profile email',  // Scope OAuth2 da richiedere (default: 'openid profile email')
})

loginWithRedirect(options?: LoginWithRedirectOptions): Promise<void>

// Login redirect base
await auris.loginWithRedirect()
 
// Apri la schermata di registrazione
await auris.loginWithRedirect({ screen_hint: 'signup' })
 
// Pre-compila l'email e forza la ri-autenticazione
await auris.loginWithRedirect({ login_hint: '[email protected]', prompt: 'login' })

handleRedirectCallback(): Promise<AuthResult>

const result = await auris.handleRedirectCallback()
 
if (result.user) {
  console.log('Autenticato come', result.user.email)
  window.location.href = '/dashboard'
}

login(email: string, password: string): Promise<AuthResult>

const result = await auris.login('[email protected]', 'hunter2')
console.log(result.user.id)

signup(email: string, password: string, options?: SignupOptions): Promise<AuthResult>

const result = await auris.signup('[email protected]', 'passwordsicura', {
  firstName: 'Bob',
  lastName: 'Smith',
})

logout(options?: LogoutOptions): Promise<void>

// Cancella i token e reindirizza alla home page
await auris.logout({ returnTo: 'http://localhost:3000' })
 
// Cancella i token senza reindirizzare (es. in un contesto Node.js)
await auris.logout()

getUser(): Promise<UserInfo | null>

const user = await auris.getUser()
if (user) {
  console.log(user.id)       // ID utente Auris
  console.log(user.email)
  console.log(user.roles)    // string[] — ruoli assegnati
  console.log(user.metadata) // Record<string, unknown>
}

isAuthenticated(): Promise<boolean>

if (await auris.isAuthenticated()) {
  // Procedi con le operazioni autenticate
}

getAccessToken(): Promise<string | null>

const token = await auris.getAccessToken()
 
// Usa il token nelle richieste API
const response = await fetch('/api/data', {
  headers: { Authorization: `Bearer ${token}` },
})

refreshToken(): Promise<AuthResult>

const result = await auris.refreshToken()
console.log(result.accessToken)

loginWithMagicLink(email: string): Promise<void>

await auris.loginWithMagicLink('[email protected]')
// Reindirizza o mostra un messaggio "Controlla la tua email"

verifyMagicLink(token: string): Promise<AuthResult>

const urlParams = new URLSearchParams(window.location.search)
const token = urlParams.get('token')
 
if (token) {
  const result = await auris.verifyMagicLink(token)
  console.log('Autenticato:', result.user)
}

forgotPassword(email: string): Promise<void>

await auris.forgotPassword('[email protected]')

loginWithSocial(provider: SocialProvider): Promise<void>

type SocialProvider =
  | 'google'
  | 'github'
  | 'microsoft'
  | 'apple'
  | 'facebook'
  | 'discord'
  | 'linkedin'
  | 'twitter'
  | 'slack'

await auris.loginWithSocial('google')
await auris.loginWithSocial('github')

getM2MToken(clientSecret: string, scopes?: string[]): Promise<M2MTokenResult>

const result = await auris.getM2MToken('cs_live_xxxxx', ['read:users', 'manage:roles'])
console.log(result.accessToken)
console.log(result.expiresIn) // secondi alla scadenza

onAuthStateChange(callback: (user: UserInfo | null) => void): Unsubscribe

const unsubscribe = auris.onAuthStateChange((user) => {
  if (user) {
    console.log('Accesso effettuato:', user.email)
  } else {
    console.log('Disconnesso')
  }
})
 
// In seguito, quando non hai più bisogno del listener:
unsubscribe()

check(permissions: string[]): Promise<PermissionCheckResult>

interface PermissionCheckResult {
  has: (permission: string) => boolean
  hasAll: boolean   // true se l'utente ha tutti i permessi nell'array
  hasAny: boolean   // true se l'utente ha almeno un permesso nell'array
  results: Record<string, boolean> // mappa risultati per-permesso
}

const result = await auris.permissions.check(['manage:users', 'view:reports'])
 
if (result.has('manage:users')) {
  // Mostra UI admin
}
 
if (result.hasAll) {
  // L'utente ha entrambi i permessi
}

checkOne(permission: string): Promise<boolean>

const puoEliminare = await auris.permissions.checkOne('delete:documents')
if (puoEliminare) {
  mostraBottoneElimina()
}

listUserPermissions(): Promise<string[]>

const permessi = await auris.permissions.listUserPermissions()
console.log(permessi) // ['view:documents', 'create:documents', 'manage:users', ...]

check(input: FgaCheckInput): Promise<FgaCheckResult>

interface FgaCheckInput {
  objectType: string   // es. 'document'
  objectId: string     // es. 'doc_abc123'
  relation: string     // es. 'viewer'
  subjectType: string  // es. 'user'
  subjectId: string    // es. l'ID dell'utente corrente
}
 
interface FgaCheckResult {
  allowed: boolean
  resolution?: ResolutionNode[] // traccia modalità explain
}

const result = await auris.fga.check({
  objectType: 'document',
  objectId: 'doc_abc123',
  relation: 'editor',
  subjectType: 'user',
  subjectId: user.id,
})
 
if (result.allowed) {
  abilitaModalitaModifica()
}

expand(input: FgaExpandInput): Promise<ExpandTree>

const tree = await auris.fga.expand({
  objectType: 'project',
  objectId: 'proj_xyz',
  relation: 'member',
})
console.log(tree)

listObjects(input: FgaListObjectsInput): Promise<string[]>

// Elenca tutti i documenti che l'utente corrente può visualizzare
const documentIds = await auris.fga.listObjects({
  objectType: 'document',
  relation: 'viewer',
  subjectType: 'user',
  subjectId: user.id,
})

writeTuples(tuples: WriteTupleInput[]): Promise<void>

await auris.fga.writeTuples([
  {
    objectType: 'document',
    objectId: 'doc_abc123',
    relation: 'editor',
    subjectType: 'user',
    subjectId: 'usr_456',
  },
])

deleteTuples(tuples: WriteTupleInput[]): Promise<void>

await auris.fga.deleteTuples([
  {
    objectType: 'document',
    objectId: 'doc_abc123',
    relation: 'editor',
    subjectType: 'user',
    subjectId: 'usr_456',
  },
])

import { createManagementClient } from '@auris/js'
 
const mgmt = await createManagementClient({
  domain: 'auth.tuodominio.com',
  clientId: 'app_xxxxx',
  clientSecret: 'cs_live_xxxxx',
  tenant: 'my-tenant',
})

// Elenca utenti con paginazione
const { users, total } = await mgmt.users.list({ page: 1, limit: 50 })
 
// Ottieni un singolo utente per ID
const user = await mgmt.users.get('usr_abc123')
 
// Crea un utente
const newUser = await mgmt.users.create({
  email: '[email protected]',
  password: 'password-temporanea',
  firstName: 'Alice',
  roles: ['editor'],
})
 
// Aggiorna un utente
await mgmt.users.update('usr_abc123', { firstName: 'Alicia' })
 
// Disabilita un utente (soft-disable — non può effettuare il login)
await mgmt.users.update('usr_abc123', { enabled: false })
 
// Elimina un utente
await mgmt.users.delete('usr_abc123')

const orgs = await mgmt.organizations.list()
const org = await mgmt.organizations.get('org_xyz')
const newOrg = await mgmt.organizations.create({ name: 'Acme Corp', slug: 'acme' })
await mgmt.organizations.update('org_xyz', { name: 'Acme Corporation' })
await mgmt.organizations.delete('org_xyz')

const roles = await mgmt.roles.list()
const role = await mgmt.roles.get('role_abc')
const newRole = await mgmt.roles.create({ name: 'Editor', description: 'Può modificare i contenuti' })
await mgmt.roles.update('role_abc', { description: 'Può visualizzare e modificare i contenuti' })
await mgmt.roles.delete('role_abc')

import { verifyWebhookSignature } from '@auris/js'
 
const isValid = await verifyWebhookSignature({
  payload: rawBody,       // string o Buffer — il corpo grezzo della richiesta
  signature: headerValue, // valore dell'header X-Webhook-Signature
  secret: 'whsec_xxxxx',  // segreto di firma dalla Console
  timestamp: headerTs,    // valore dell'header X-Webhook-Timestamp
  maxAge: 300,            // opzionale: rifiuta webhook più vecchi di N secondi (default: 300)
})

import express from 'express'
import { verifyWebhookSignature } from '@auris/js'
 
const app = express()
 
app.post('/webhooks/auris', express.raw({ type: 'application/json' }), async (req, res) => {
  const isValid = await verifyWebhookSignature({
    payload: req.body.toString('utf-8'),
    signature: req.headers['x-webhook-signature'],
    secret: process.env.AURIS_WEBHOOK_SECRET,
    timestamp: req.headers['x-webhook-timestamp'],
  })
 
  if (!isValid) {
    return res.status(401).json({ error: 'Firma non valida' })
  }
 
  const event = JSON.parse(req.body)
  console.log('Evento ricevuto:', event.type)
  res.json({ received: true })
})

import { verifyJwt } from '@auris/js'
 
const payload = await verifyJwt(token, 'https://auth.tuodominio.com/.well-known/jwks.json')

import { verifyJwt } from '@auris/js'
 
try {
  const payload = await verifyJwt(
    accessToken,
    `https://${process.env.AURIS_DOMAIN}/.well-known/jwks.json`
  )
  console.log('ID Utente:', payload.sub)
  console.log('Ruoli:', payload.roles)
} catch (err) {
  console.error('Token non valido:', err.message)
}

// Risultati autenticazione
interface AuthResult {
  user: UserInfo
  accessToken: string
  refreshToken?: string
  expiresIn: number
  tokenType: 'Bearer'
}
 
// Informazioni utente
interface UserInfo {
  id: string
  sub: string
  email: string
  emailVerified: boolean
  name: string
  firstName: string
  lastName: string
  username: string
  picture?: string
  roles: string[]
  metadata: Record<string, unknown>
  tenant: string
  createdAt: string
}
 
// Risultato token M2M
interface M2MTokenResult {
  accessToken: string
  expiresIn: number
  tokenType: 'Bearer'
  scope: string
}
 
// Risultato verifica permesso
interface PermissionCheckResult {
  has: (permission: string) => boolean
  hasAll: boolean
  hasAny: boolean
  results: Record<string, boolean>
}
 
// Tipi FGA
interface FgaCheckInput {
  objectType: string
  objectId: string
  relation: string
  subjectType: string
  subjectId: string
  subjectRelation?: string
}
 
interface FgaCheckResult {
  allowed: boolean
  resolution?: ResolutionNode[]
}
 
// Interfaccia adapter di archiviazione
interface TokenStore {
  get(key: string): string | null | Promise<string | null>
  set(key: string, value: string): void | Promise<void>
  remove(key: string): void | Promise<void>
}
 
// Funzione di disiscrizione da onAuthStateChange
type Unsubscribe = () => void

import { AurisClient, TokenStore } from '@auris/js'
 
class RedisTokenStore implements TokenStore {
  constructor(private redis: RedisClient, private prefix = 'auris:') {}
 
  async get(key: string) {
    return this.redis.get(this.prefix + key)
  }
 
  async set(key: string, value: string) {
    await this.redis.set(this.prefix + key, value, { EX: 60 * 60 * 24 })
  }
 
  async remove(key: string) {
    await this.redis.del(this.prefix + key)
  }
}
 
const auris = new AurisClient({
  domain: 'auth.tuodominio.com',
  clientId: 'app_xxxxx',
  storage: new RedisTokenStore(redisClient),
})

import { AurisClient, AurisError } from '@auris/js'
 
try {
  await auris.login('[email protected]', 'passworderrata')
} catch (err) {
  if (err instanceof AurisError) {
    console.error(err.code)    // es. 'invalid_credentials', 'account_locked', 'mfa_required'
    console.error(err.message) // Messaggio leggibile
    console.error(err.status)  // Codice di stato HTTP (es. 401, 403, 429)
  }
}