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.votredomaine.com',  // Domaine du tenant Auris (obligatoire)
  clientId: 'app_xxxxx',            // Client ID de l'application depuis la Console (obligatoire)
  redirectUri: 'http://localhost:3000/callback', // Doit correspondre à un Callback URL enregistré (obligatoire pour les flux PKCE)
  tenant: 'my-tenant',              // Identifiant tenant envoyé comme en-tête x-tenant (optionnel)
  storage: 'localStorage',          // Stockage des tokens : 'localStorage' | 'sessionStorage' | 'memory' | instance TokenStore
  autoRefresh: true,                // Rafraîchit automatiquement les tokens d'accès avant expiration (défaut : true)
  scope: 'openid profile email',    // Scopes OAuth2 à demander (défaut : 'openid profile email')
})

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

// Redirection de connexion basique
await auris.loginWithRedirect()
 
// Ouvrir l'écran d'inscription
await auris.loginWithRedirect({ screen_hint: 'signup' })
 
// Pré-remplir l'email et forcer la ré-authentification
await auris.loginWithRedirect({ login_hint: '[email protected]', prompt: 'login' })

handleRedirectCallback(): Promise<AuthResult>

const result = await auris.handleRedirectCallback()
 
if (result.user) {
  console.log('Authentifié en tant que', 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]', 'motdepassesécurisé', {
  firstName: 'Bob',
  lastName: 'Smith',
})

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

// Supprime les tokens et redirige vers la page d'accueil
await auris.logout({ returnTo: 'http://localhost:3000' })
 
// Supprime les tokens sans rediriger (ex. dans un contexte Node.js)
await auris.logout()

getUser(): Promise<UserInfo | null>

const user = await auris.getUser()
if (user) {
  console.log(user.id)       // ID utilisateur Auris
  console.log(user.email)
  console.log(user.roles)    // string[] — rôles assignés
  console.log(user.metadata) // Record<string, unknown>
}

isAuthenticated(): Promise<boolean>

if (await auris.isAuthenticated()) {
  // Procéder aux opérations authentifiées
}

getAccessToken(): Promise<string | null>

const token = await auris.getAccessToken()
 
// Utiliser le token dans les requêtes 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]')
// Redirige ou affiche un message "Vérifie ton 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('Authentifié :', 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) // secondes avant expiration

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

const unsubscribe = auris.onAuthStateChange((user) => {
  if (user) {
    console.log('Connecté :', user.email)
  } else {
    console.log('Déconnecté')
  }
})
 
// Plus tard, quand tu n'as plus besoin du listener :
unsubscribe()

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

interface PermissionCheckResult {
  has: (permission: string) => boolean
  hasAll: boolean   // true si l'utilisateur a tous les permissions dans le tableau
  hasAny: boolean   // true si l'utilisateur a au moins un permission dans le tableau
  results: Record<string, boolean> // carte des résultats par permission
}

const result = await auris.permissions.check(['manage:users', 'view:reports'])
 
if (result.has('manage:users')) {
  // Afficher l'UI admin
}
 
if (result.hasAll) {
  // L'utilisateur a les deux permissions
}

checkOne(permission: string): Promise<boolean>

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

listUserPermissions(): Promise<string[]>

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

check(input: FgaCheckInput): Promise<FgaCheckResult>

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

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[]>

// Lister tous les documents que l'utilisateur courant peut voir
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.votredomaine.com',
  clientId: 'app_xxxxx',
  clientSecret: 'cs_live_xxxxx',
  tenant: 'my-tenant',
})

// Lister les utilisateurs avec pagination
const { users, total } = await mgmt.users.list({ page: 1, limit: 50 })
 
// Obtenir un seul utilisateur par ID
const user = await mgmt.users.get('usr_abc123')
 
// Créer un utilisateur
const newUser = await mgmt.users.create({
  email: '[email protected]',
  password: 'mot-de-passe-temporaire',
  firstName: 'Alice',
  roles: ['editor'],
})
 
// Mettre à jour un utilisateur
await mgmt.users.update('usr_abc123', { firstName: 'Alicia' })
 
// Désactiver un utilisateur (soft-disable — ne peut pas se connecter)
await mgmt.users.update('usr_abc123', { enabled: false })
 
// Supprimer un utilisateur
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: 'Éditeur', description: 'Peut modifier les contenus' })
await mgmt.roles.update('role_abc', { description: 'Peut voir et modifier les contenus' })
await mgmt.roles.delete('role_abc')

import { verifyWebhookSignature } from '@auris/js'
 
const isValid = await verifyWebhookSignature({
  payload: rawBody,       // string ou Buffer — le corps brut de la requête
  signature: headerValue, // valeur de l'en-tête X-Webhook-Signature
  secret: 'whsec_xxxxx',  // secret de signature depuis la Console
  timestamp: headerTs,    // valeur de l'en-tête X-Webhook-Timestamp
  maxAge: 300,            // optionnel : rejette les webhooks plus anciens que N secondes (défaut : 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: 'Signature invalide' })
  }
 
  const event = JSON.parse(req.body)
  console.log('Événement reçu :', event.type)
  res.json({ received: true })
})

import { verifyJwt } from '@auris/js'
 
const payload = await verifyJwt(token, 'https://auth.votredomaine.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 Utilisateur :', payload.sub)
  console.log('Rôles :', payload.roles)
} catch (err) {
  console.error('Token invalide :', err.message)
}

// Résultats d'authentification
interface AuthResult {
  user: UserInfo
  accessToken: string
  refreshToken?: string
  expiresIn: number
  tokenType: 'Bearer'
}
 
// Informations utilisateur
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
}
 
// Résultat token M2M
interface M2MTokenResult {
  accessToken: string
  expiresIn: number
  tokenType: 'Bearer'
  scope: string
}
 
// Résultat vérification permission
interface PermissionCheckResult {
  has: (permission: string) => boolean
  hasAll: boolean
  hasAny: boolean
  results: Record<string, boolean>
}
 
// Types FGA
interface FgaCheckInput {
  objectType: string
  objectId: string
  relation: string
  subjectType: string
  subjectId: string
  subjectRelation?: string
}
 
interface FgaCheckResult {
  allowed: boolean
  resolution?: ResolutionNode[]
}
 
// Interface adaptateur de stockage
interface TokenStore {
  get(key: string): string | null | Promise<string | null>
  set(key: string, value: string): void | Promise<void>
  remove(key: string): void | Promise<void>
}
 
// Fonction de désabonnement de 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.votredomaine.com',
  clientId: 'app_xxxxx',
  storage: new RedisTokenStore(redisClient),
})

import { AurisClient, AurisError } from '@auris/js'
 
try {
  await auris.login('[email protected]', 'mauvaisMotDePasse')
} catch (err) {
  if (err instanceof AurisError) {
    console.error(err.code)    // ex. 'invalid_credentials', 'account_locked', 'mfa_required'
    console.error(err.message) // Message lisible
    console.error(err.status)  // Code de statut HTTP (ex. 401, 403, 429)
  }
}