Aller au contenu principal

Serveur & Fédération

Cette page couvre les API permettant d'interroger les métadonnées du serveur, la fédération, les rôles, les graphiques et ActivityPub.

MetaApi​

client.meta fournit les métadonnées du serveur et la détection des fonctionnalités.

Récupérer les métadonnées​

final meta = await client.meta.getMeta();
print(meta.name);        // Server name
print(meta.description); // Server description

Les résultats sont mis en cache en mémoire après le premier appel. Utilisez refresh: true pour contourner le cache :

final fresh = await client.meta.getMeta(refresh: true);

Passez detail: false pour une réponse allégée (équivalent à MetaLite) :

final lite = await client.meta.getMeta(detail: false);

Présence des clés de métadonnées​

Appelez getMeta() au moins une fois avant d'utiliser hasMetaKey(). Cette méthode vérifie uniquement la présence d'une clé dans la réponse brute avec une notation par points. Elle n'interprète pas la valeur : une valeur booléenne false compte toujours comme présente.

await client.meta.getMeta();

if (client.meta.hasMetaKey('features.miauth')) {
  // La clé existe ; inspectez sa valeur pour déterminer l'activation.
}

Informations, statistiques et ping du serveur​

// Machine info: CPU, memory, disk
final info = await client.meta.getServerInfo();
print(info.cpu.model);
print(info.mem.total);

// Instance statistics: user count, note count, etc.
final stats = await client.meta.getStats();
print(stats.usersCount);
print(stats.notesCount);

// Ping — returns the server time as a Unix timestamp (ms)
final timestamp = await client.meta.ping();

Points d'accès​

// All endpoint names
final endpoints = await client.meta.getEndpoints();

// Vérification préalable recommandée pour les API ajoutées récemment
final canCreateDrafts = await client.meta.isEndpointAvailable(
  endpoint: 'notes/drafts/create',
);

// Parameters for a specific endpoint
final info = await client.meta.getEndpoint(endpoint: 'notes/create');
if (info != null) {
  for (final param in info.params) {
    print('${param.name}: ${param.type}');
  }
}

L'énumération des points de terminaison est mise en cache ; passez refresh: true après une mise à niveau du serveur. Préférez-la à la comparaison de Meta.version, surtout pour les forks ayant leurs propres versions. Le résultat n'est qu'un instantané : gérez toujours MisskeyNotFoundException lors de l'appel réel. Si /api/endpoints n'est pas disponible, appelez directement l'API souhaitée et gérez sa réponse 404 potentiellement ambiguë.

Emojis personnalisés​

// Full emoji list (sorted by category and name)
final emojis = await client.meta.getEmojis();

// Details for a single emoji by shortcode
final emoji = await client.meta.getEmoji(name: 'blobcat');
print(emoji.url);

Autres requêtes serveur​

// Users pinned by administrators
final pinned = await client.meta.getPinnedUsers();

// Count of users active in the last few minutes (cached 60 s)
final count = await client.meta.getOnlineUsersCount();

// Available avatar decorations
final decorations = await client.meta.getAvatarDecorations();

// User retention data — up to 30 daily records (cached 3600 s)
final retention = await client.meta.getRetention();
for (final record in retention) {
  print('${record.createdAt}: ${record.users} registrations');
}

FederationApi​

client.federation fournit des informations sur les instances avec lesquelles le serveur est fédéré.

Lister les instances​

// All known federated instances
final instances = await client.federation.instances(limit: 30);

// Filter by status flags
final blocked = await client.federation.instances(blocked: true, limit: 20);
final suspended = await client.federation.instances(suspended: true);
final active = await client.federation.instances(federating: true, limit: 50);

// Sort by follower count (descending)
final top = await client.federation.instances(
  sort: '-followers',
  limit: 10,
);

Valeurs sort disponibles : +pubSub / -pubSub, +notes / -notes, +users / -users, +following / -following, +followers / -followers, +firstRetrievedAt / -firstRetrievedAt, +latestRequestReceivedAt / -latestRequestReceivedAt.

Détails d'une instance​

final instance = await client.federation.showInstance(host: 'mastodon.social');
if (instance != null) {
  print(instance.usersCount);
  print(instance.notesCount);
}

Abonnés et abonnements pour un hôte​

// Relationships followed from a remote instance
final followers = await client.federation.followers(
  host: 'mastodon.social',
  limit: 20,
);

final following = await client.federation.following(
  host: 'mastodon.social',
  limit: 20,
);

// Users known from a remote instance
final users = await client.federation.users(
  host: 'mastodon.social',
  limit: 20,
);

Statistiques de fédération​

// Top instances by follower/following counts
final stats = await client.federation.stats(limit: 10);
print(stats.topSubInstances.first.host);

Actualiser un utilisateur distant​

// Re-fetch the ActivityPub profile for a remote user (requires auth)
await client.federation.updateRemoteUser(userId: remoteUserId);

RolesApi​

client.roles expose les informations publiques sur les rôles.

// List all public, explorable roles (requires auth)
final roles = await client.roles.list();

// Details for a specific role (no auth required)
final role = await client.roles.show(roleId: 'roleId123');
print(role.name);
print(role.color);

// Notes from users belonging to a role (requires auth)
final notes = await client.roles.notes(roleId: role.id, limit: 20);

// Users belonging to a role (no auth required)
final members = await client.roles.users(roleId: role.id, limit: 20);

Toutes les méthodes de liste acceptent sinceId, untilId, sinceDate et untilDate pour la pagination.

ChartsApi​

client.charts retourne des données de séries temporelles. Toutes les méthodes acceptent span ('day' ou 'hour'), limit (1-500, défaut 30) et offset.

// Active users over the last 30 days
final activeUsers = await client.charts.getActiveUsers(span: 'day');

// Note counts (local and remote)
final notes = await client.charts.getNotes(span: 'day', limit: 14);

// User counts (local and remote)
final users = await client.charts.getUsers(span: 'hour', limit: 24);

// Federation activity
final fed = await client.charts.getFederation(span: 'day');

// ActivityPub request outcomes
final ap = await client.charts.getApRequest(span: 'hour', limit: 48);

// Per-instance chart
final inst = await client.charts.getInstance(
  host: 'mastodon.social',
  span: 'day',
  limit: 7,
);

// Per-user charts
final userNotes = await client.charts.getUserNotes(
  userId: userId,
  span: 'day',
  limit: 30,
);

Chaque réponse est un Map<String, dynamic> dont les valeurs feuilles sont des tableaux de séries temporelles List<num>.

ApApi​

client.ap résout les objets ActivityPub depuis des serveurs distants (authentification requise, limite de débit : 30/heure).

// Resolve a user or note from an AP URI
final result = await client.ap.show(
  uri: 'https://mastodon.social/users/alice',
);
if (result is ApShowUser) {
  print(result.user.username);
} else if (result is ApShowNote) {
  print(result.note.text);
}

// Fetch the raw AP object (admin-only)
final raw = await client.ap.get(
  uri: 'https://mastodon.social/users/alice',
);
print(raw['type']); // e.g. 'Person'