Taxonomies

Les taxonomies sont des systèmes de classification pour organiser le contenu. EmDash inclut des catégories et des étiquettes intégrées, et prend en charge des taxonomies personnalisées pour des besoins de classification spécialisés.

Taxonomies intégrées

EmDash fournit deux taxonomies par défaut :

Taxonomie	Type	Description
Catégories	Hiérarchique	Classification imbriquée avec relations parent-enfant
Étiquettes	Plate	Étiquettes simples sans hiérarchie

Les deux sont disponibles pour la collection de publications par défaut.

Gestion des termes

Créer un terme

Admin Dashboard

Accédez à la page de taxonomie (par exemple, /_emdash/admin/taxonomies/category)
Entrez le nom du terme dans le formulaire Ajouter nouveau
Définissez éventuellement :
- Slug - Identifiant d’URL (généré automatiquement à partir du nom)
- Parent - Pour les taxonomies hiérarchiques
- Description - Description du terme
Cliquez sur Ajouter

Content Editor

Ouvrez une entrée de contenu dans l’éditeur
Trouvez le panneau de taxonomie dans la barre latérale
Pour les catégories, cochez les cases des termes applicables, ou cliquez sur + Ajouter nouveau
Pour les étiquettes, tapez les noms d’étiquettes séparés par des virgules
Enregistrez le contenu

API

La requête suivante crée un terme dans la taxonomie category :

POST /_emdash/api/taxonomies/category/terms
Content-Type: application/json
Authorization: Bearer YOUR_API_TOKEN

{
  "slug": "tutorials",
  "label": "Tutorials",
  "parentId": "term_abc",
  "description": "How-to guides and tutorials"
}

Modifier un terme

Accédez à la page des termes de taxonomie
Cliquez sur Modifier à côté du terme
Mettez à jour le nom, le slug, le parent ou la description
Cliquez sur Enregistrer

Supprimer un terme

Accédez à la page des termes de taxonomie
Cliquez sur Supprimer à côté du terme
Confirmez la suppression

Interroger les taxonomies

EmDash fournit des fonctions pour interroger les termes de taxonomie et filtrer le contenu par terme.

Obtenir tous les termes

Récupérer tous les termes d’une taxonomie :

import { getTaxonomyTerms } from "emdash";

// Get all categories (returns tree structure)
const categories = await getTaxonomyTerms("category");

// Get all tags (returns flat list)
const tags = await getTaxonomyTerms("tag");

Pour les taxonomies hiérarchiques, les termes incluent un tableau children :

interface TaxonomyTerm {
	id: string;
	name: string; // Taxonomy name ("category")
	slug: string; // Term slug ("news")
	label: string; // Display label ("News")
	parentId?: string;
	description?: string;
	children: TaxonomyTerm[];
	count?: number; // Number of entries with this term
}

Obtenir un terme unique

L’exemple suivant récupère un terme par taxonomie et slug :

import { getTerm } from "emdash";

const category = await getTerm("category", "news");
// Returns TaxonomyTerm or null

Obtenir les termes d’une entrée

L’exemple suivant récupère les catégories et étiquettes attribuées à une seule entrée :

import { getEntryTerms } from "emdash";

// Get all categories for a post
const categories = await getEntryTerms("posts", "post-123", "category");

// Get all tags for a post
const tags = await getEntryTerms("posts", "post-123", "tag");

Filtrer le contenu par terme

Utilisez getEmDashCollection avec le filtre where :

import { getEmDashCollection } from "emdash";

// Posts in the "news" category
const { entries: newsPosts } = await getEmDashCollection("posts", {
	status: "published",
	where: { category: "news" },
});

// Posts with the "javascript" tag
const { entries: jsPosts } = await getEmDashCollection("posts", {
	status: "published",
	where: { tag: "javascript" },
});

Ou utilisez la fonction de commodité :

import { getEntriesByTerm } from "emdash";

const newsPosts = await getEntriesByTerm("posts", "category", "news");

Créer des pages de taxonomie

Archive de catégories

Créez une page qui liste les publications dans une catégorie :

---
import { getTaxonomyTerms, getTerm, getEmDashCollection } from "emdash";
import Base from "../../layouts/Base.astro";

export async function getStaticPaths() {
  const categories = await getTaxonomyTerms("category");

  // Flatten hierarchical tree for routing
  function flatten(terms) {
    return terms.flatMap((term) => [term, ...flatten(term.children)]);
  }

  return flatten(categories).map((cat) => ({
    params: { slug: cat.slug },
    props: { category: cat },
  }));
}

const { category } = Astro.props;

const { entries: posts } = await getEmDashCollection("posts", {
  status: "published",
  where: { category: category.slug },
});
---

<Base title={category.label}>
  <h1>{category.label}</h1>
  {category.description && <p>{category.description}</p>}
  <p>{category.count} posts</p>

  <ul>
    {posts.map((post) => (
      <li>
        <a href={`/blog/${post.data.slug}`}>{post.data.title}</a>
      </li>
    ))}
  </ul>
</Base>

Archive d’étiquettes

Créez une page qui liste les publications avec une étiquette :

---
import { getTaxonomyTerms, getEmDashCollection } from "emdash";
import Base from "../../layouts/Base.astro";

export async function getStaticPaths() {
  const tags = await getTaxonomyTerms("tag");

  return tags.map((tag) => ({
    params: { slug: tag.slug },
    props: { tag },
  }));
}

const { tag } = Astro.props;

const { entries: posts } = await getEmDashCollection("posts", {
  status: "published",
  where: { tag: tag.slug },
});
---

<Base title={`Posts tagged "${tag.label}"`}>
  <h1>#{tag.label}</h1>

  <ul>
    {posts.map((post) => (
      <li>
        <a href={`/blog/${post.data.slug}`}>{post.data.title}</a>
      </li>
    ))}
  </ul>
</Base>

Affichez une liste de catégories avec le nombre de publications :

---
import { getTaxonomyTerms } from "emdash";

const categories = await getTaxonomyTerms("category");
---

<nav class="category-list">
  <h3>Categories</h3>
  <ul>
    {categories.map((cat) => (
      <li>
        <a href={`/category/${cat.slug}`}>
          {cat.label} ({cat.count})
        </a>
        {cat.children.length > 0 && (
          <ul>
            {cat.children.map((child) => (
              <li>
                <a href={`/category/${child.slug}`}>
                  {child.label} ({child.count})
                </a>
              </li>
            ))}
          </ul>
        )}
      </li>
    ))}
  </ul>
</nav>

Nuage d’étiquettes

Affichez les étiquettes avec une taille basée sur l’utilisation :

---
import { getTaxonomyTerms } from "emdash";

const tags = await getTaxonomyTerms("tag");

// Calculate font sizes based on count
const counts = tags.map((t) => t.count ?? 0);
const maxCount = Math.max(...counts, 1);
const minSize = 0.8;
const maxSize = 2;

function getSize(count: number) {
  const ratio = count / maxCount;
  return minSize + ratio * (maxSize - minSize);
}
---

<div class="tag-cloud">
  {tags.map((tag) => (
    <a
      href={`/tag/${tag.slug}`}
      style={`font-size: ${getSize(tag.count ?? 0)}rem`}
    >
      {tag.label}
    </a>
  ))}
</div>

Afficher les termes sur le contenu

Affichez les catégories et étiquettes sur une publication :

---
import { getEntryTerms } from "emdash";

interface Props {
  collection: string;
  entryId: string;
}

const { collection, entryId } = Astro.props;

const categories = await getEntryTerms(collection, entryId, "category");
const tags = await getEntryTerms(collection, entryId, "tag");
---

<div class="post-terms">
  {categories.length > 0 && (
    <div class="categories">
      <span>Posted in:</span>
      {categories.map((cat, i) => (
        <>
          {i > 0 && ", "}
          <a href={`/category/${cat.slug}`}>{cat.label}</a>
        </>
      ))}
    </div>
  )}

  {tags.length > 0 && (
    <div class="tags">
      {tags.map((tag) => (
        <a href={`/tag/${tag.slug}`} class="tag">
          #{tag.label}
        </a>
      ))}
    </div>
  )}
</div>

Taxonomies personnalisées

Créez des taxonomies au-delà des catégories et des étiquettes pour des besoins spécialisés.

Créer une taxonomie personnalisée

Utilisez l’API d’administration pour créer une taxonomie :

POST /_emdash/api/taxonomies
Content-Type: application/json
Authorization: Bearer YOUR_API_TOKEN

{
  "name": "genre",
  "label": "Genres",
  "labelSingular": "Genre",
  "hierarchical": true,
  "collections": ["books", "movies"]
}

Utiliser des taxonomies personnalisées

Interrogez et affichez les taxonomies personnalisées de la même manière que les taxonomies intégrées :

import { getTaxonomyTerms, getEmDashCollection } from "emdash";

// Get all genres
const genres = await getTaxonomyTerms("genre");

// Get books in a genre
const { entries: sciFiBooks } = await getEmDashCollection("books", {
	where: { genre: "science-fiction" },
});

Attribuer aux collections

Les taxonomies spécifient à quelles collections elles s’appliquent :

{
  "name": "difficulty",
  "label": "Difficulty Levels",
  "hierarchical": false,
  "collections": ["recipes", "tutorials"]
}

Référence de l’API de taxonomie

Points de terminaison REST

Endpoint	Méthode	Description
`/_emdash/api/taxonomies`	GET	Lister les définitions de taxonomie
`/_emdash/api/taxonomies`	POST	Créer une taxonomie
`/_emdash/api/taxonomies/:name/terms`	GET	Lister les termes
`/_emdash/api/taxonomies/:name/terms`	POST	Créer un terme
`/_emdash/api/taxonomies/:name/terms/:slug`	GET	Obtenir un terme
`/_emdash/api/taxonomies/:name/terms/:slug`	PUT	Mettre à jour un terme
`/_emdash/api/taxonomies/:name/terms/:slug`	DELETE	Supprimer un terme

Attribuer des termes au contenu

La requête suivante attribue des termes de catégorie à une publication :

POST /_emdash/api/content/posts/post-123/terms/category
Content-Type: application/json
Authorization: Bearer YOUR_API_TOKEN

{
  "termIds": ["term_news", "term_featured"]
}

Prochaines étapes

Créer un blog - Utiliser des catégories et des étiquettes dans un blog
Interroger le contenu - Filtrer par termes de taxonomie
Travailler avec le contenu - Attribuer des termes dans l’éditeur