Changeset b0ccd0d in Klonkt for src

Timestamp:

08/22/2026 08:14:01 AM (3 weeks ago)

Author:

Robin <roboburr@…>

Branches:

main

Children:

25dd08f

Parents:

8ed36de

Message:

De mixtape als eigen soort: data en draad

Een bandje is geen album en geen afspeellijst. Een album is een uitgave -- de
nummers bestaan er los van. Bij een mixtape is de VOLGORDE het werk en zijn de
nummers onderdelen. Vandaar een eigen soort, en op de draad een enkel object
met de nummers erin.

De valkuil zat in de vorm die er al stond. De keuze album/playlist stond vijf
keer als x === 'playlist' ? 'playlist' : 'album' verspreid over drie
bestanden, en zo'n vorm valt bij een derde soort niet om -- hij slikt hem. Een
mixtape zou stilzwijgend een album zijn geworden en als Album de deur uit gaan.
De lijst staat nu een keer, in de pure gedeelde module, want die kent de
browser ook.

Op de draad:

• type is de STRING 'Mixtape'. Geen array, en dat is geleerd: bij de playlist-collectie stond ooit ['OrderedCollection','Album'] -- geldig AS2 en werkelijk allebei -- en een lezer die type als tekst uitpakt (Shaer) verloor daarmee stil het hele object.
• orderedItems op het object zelf, niet een collectie ernaast.
• Geen released en geen musicbrainzId: die zouden beweren dat dit een uitgave is.
• Geen eigen url. Robins keuze: het bandje is een omhulling, geen gerenderd bestand. Prijs ervan is opgeschreven bij de functie -- wie het type niet kent heeft geen stream, al staan de nummers er stuk voor stuk in.

Een mixtape met losse tracks erbij blijft een mixtape. De oude regel maakte
daar een album van met bonustracks; dat klopt voor een plaat en niet voor een
bandje. Album en playlist houden bewust hun oude gedrag, want dat zijn
bestaande posts.

Acht tests, waaronder de weg door de database heen in plaats van langs een
handgemaakte opzoeker.

Co-Authored-By: Claude Opus 5 <noreply@…>

Location:

src

Files:

• assets/js/shared/post-music-type.js (modified) (4 diffs)
• services/PlaylistService.js (modified) (8 diffs)
• services/music/index.js (modified) (5 diffs)

src/assets/js/shared/post-music-type.js

@@ -21 +21 @@
  *   een collectie                 -> die soort  metadata van de post geleend
  *   een collectie + losse tracks  -> album      de losse zijn BONUS-TRACKS
+ *   een MIXTAPE + losse tracks    -> mixtape    de losse zijn BONUS-TRACKS
  *   twee of meer collecties       -> post       NIETS geleend
+ *
+ * Die vierde regel is de uitzondering op de derde en staat er met opzet naast:
+ * bonustracks maken van een uitgave een album, maar een bandje is geen uitgave.
  *
  * Waarom de lening bij de laatste vervalt: die bestaat omdat een collectie soms
@@ -39 +43 @@
 // insluit, telt hier niet mee. Anders zou een shortcode die niets oplevert wel
 // het type van de post kunnen bepalen.
+// De soorten die een playlist kan zijn, en dit is de ENIGE lijst. PlaylistService
+// en music/index.js halen hem hier op, precies omdat het andersom niet kan:
+// deze module draait ook in de browser en mag niets van de database weten.
+//
+// Waarom dat uitmaakt: bij twee soorten stond de keuze vijf keer als
+// `x === 'playlist' ? 'playlist' : 'album'` verspreid over drie bestanden. Zo'n
+// vorm valt niet om bij een derde soort, hij slikt hem -- een mixtape werd
+// stilzwijgend een album en ging als Album de deur uit.
+export const SOORTEN = ['album', 'playlist', 'mixtape'];
+
 const RE_PLAYLIST = /\[\[playlist:([a-z0-9][a-z0-9-]*)\]\]/gi;
 const RE_ALBUM    = /\[\[album:([^\]]+)\]\]/g;
@@ -64 +78 @@
   const uitPlaylists = playlists.map((id) => {
     const kind = zoek(id);
-    if (kind !== 'album' && kind !== 'playlist') { onbekend.push(id); return null; }
+    if (!SOORTEN.includes(kind)) { onbekend.push(id); return null; }
     return { soort: kind, id };
   }).filter(Boolean);
@@ -87 +101 @@
   if (collecties.length === 1) {
     const c0 = collecties[0];
+    // EEN MIXTAPE BLIJFT EEN MIXTAPE, ook met losse tracks erbij. De regel
+    // hieronder maakt van collectie + losse tracks een album met bonustracks, en
+    // dat klopt voor een uitgave: extra nummers bij een plaat zijn bonus. Een
+    // bandje is geen uitgave. Er een album van maken omdat er een los nummer
+    // naast staat zou het ding hernoemen op grond van iets wat er niet bij
+    // hoort. Album en playlist houden bewust hun oude gedrag: dat zijn
+    // bestaande posts en die mogen hier niet stilletjes van soort wisselen.
+    if (c0.soort === 'mixtape') {
+      return { type: 'mixtape', collectie: c0, tracks: [], bonus: tracks, leentMetadata: true };
+    }
     // Losse tracks naast een collectie zijn geen rommelrestje maar bonus-tracks,
     // en dat maakt het geheel een album.

src/services/PlaylistService.js

@@ -14 +14 @@
 import db from '../config/database.js';
 import { v4 as uuid } from 'uuid';
+import { SOORTEN } from '../assets/js/shared/post-music-type.js';
 
 /**
@@ -41 +42 @@
   return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(s) ? s : null;
 }
+
+/**
+ * De drie soorten die een playlist kan zijn, op EEN plek.
+ *
+ * Stond eerder vijf keer als `data.kind === 'playlist' ? 'playlist' : 'album'`
+ * verspreid over dit bestand. Met twee soorten kon dat nog; bij een derde is
+ * het een fout die staat te wachten, want een van de vijf vergeten betekent dat
+ * een mixtape stilletjes als album wordt opgeslagen en als Album de deur uit
+ * gaat.
+ *
+ * Album blijft de terugval: een onbekende waarde hoort niet stilzwijgend iets
+ * nieuws te worden. De lijst zelf staat in de gedeelde pure module, want de
+ * editor in de browser moet dezelfde drie kennen.
+ */
+export function normKind(v) {
+  const s = String(v == null ? '' : v).trim().toLowerCase();
+  return SOORTEN.includes(s) ? s : 'album';
+}
+
+/**
+ * Draagt deze soort uitgavegegevens? Alleen een album. Een afspeellijst en een
+ * mixtape hebben geen uitgavedatum en geen release-id: het zijn samenstellingen
+ * van andermans of eigen werk, geen uitgave op zichzelf.
+ */
+export const isUitgave = (kind) => normKind(kind) === 'album';
 
 class PlaylistService {
@@ -92 +118 @@
       year: r.year || 0,
       cover: r.cover_url || '',
-      kind: r.kind || 'album',
+      kind: normKind(r.kind),
       release_date: r.release_date || '',
       mb_release_id: r.mb_release_id || '',
@@ -154 +180 @@
       year: p.year || 0,
       cover: p.cover_url || fallbackCover,
-      kind: (p.kind === 'playlist') ? 'playlist' : 'album',
+      kind: normKind(p.kind),
       // created_at hoort erbij omdat de AP-kant er `published` van maakt. Zonder
       // dit veld viel buildAlbumObject terug op 1970, en dat stond op 16-8
@@ -162 +188 @@
       // maar dit is de plek waar de editor leest en die mag niet afhangen van
       // wat er toevallig in de kolom stond.
-      release_date: p.kind === 'playlist' ? '' : (p.release_date || ''),
-      mb_release_id: p.kind === 'playlist' ? '' : (p.mb_release_id || ''),
+      release_date: isUitgave(p.kind) ? (p.release_date || '') : '',
+      mb_release_id: isUitgave(p.kind) ? (p.mb_release_id || '') : '',
       tracks: mappedTracks,
     };
@@ -178 +204 @@
     const id = this.generateId(siteId, title);
     const now = new Date().toISOString();
-    const kind = data.kind === 'playlist' ? 'playlist' : 'album';
+    const kind = normKind(data.kind);
 
     // Alleen een UITGAVE draagt deze twee. Een afspeellijst heeft geen
@@ -186 +212 @@
     // voor de post-editor -- en dan staat er stille rommel op een mixtape die
     // later als Album de deur uit gaat.
-    const uitgave = kind === 'album';
+    const uitgave = isUitgave(kind);
     const releaseDate = uitgave ? normDatum(data.release_date) : null;
     const mbRelease = uitgave ? normMbid(data.mb_release_id) : null;
@@ -229 +255 @@
     // val terug op wat er ligt.
     const nieuwKind = Object.prototype.hasOwnProperty.call(data, 'kind')
-      ? (data.kind === 'playlist' ? 'playlist' : 'album')
-      : (existing.kind || 'album');
+      ? normKind(data.kind)
+      : normKind(existing.kind);
     if (Object.prototype.hasOwnProperty.call(data, 'title')) {
       const v = String(data.title || '').trim();

src/services/music/index.js

@@ -15 +15 @@
 import db from '../../config/database.js';
 import { AP_CONTEXT, PUBLIC, actorId, noteId, safeUrl, guessMediaType, buildHashtagList, pagedCollection, isMbid } from '../ap-core.js';
-import { afleidenUitInsluitingen, ingeslotenPlaylists } from '../../assets/js/shared/post-music-type.js';
+import { afleidenUitInsluitingen, ingeslotenPlaylists, SOORTEN } from '../../assets/js/shared/post-music-type.js';
 // De luisteraars horen bij de muziekkant; hier doorgegeven zodat
 // ActivityPubService niet in een submap hoeft te grijpen.
@@ -495 +495 @@
  * een heeft.
  */
+/**
+ * Het bandje: EEN object, samengesteld uit de nummers van een playlist.
+ *
+ * Waarom het een eigen soort is en geen album met een ander jasje. Een album is
+ * een uitgave: het heeft een uitgavedatum, een release-id, en de nummers
+ * bestaan er los van. Een mixtape is het omgekeerde -- de volgorde IS het werk,
+ * en de nummers zijn er onderdelen van. Vandaar `orderedItems` op het object
+ * zelf in plaats van een collectie ernaast, en vandaar geen `released` en geen
+ * `musicbrainzId`: die zouden beweren dat dit een uitgave is.
+ *
+ * GEEN EIGEN `url`, en dat is een keuze van Robin (21-8) met een prijs die het
+ * waard is om hier op te schrijven. Het bandje is een logische omhulling, geen
+ * gerenderd bestand: er wordt niets samengevoegd. Een ontvanger die `Mixtape`
+ * niet kent heeft dus geen stream om te spelen. Dat is bewust -- de nummers
+ * staan er stuk voor stuk in, met hun eigen id en hun eigen url, dus er gaat
+ * niets verloren; het kost alleen een consument die het type wel begrijpt.
+ *
+ * `type` is een STRING en geen array. Dat is geen slordigheid maar een geleerde
+ * les: er stond bij de playlist-collectie ooit ['OrderedCollection', 'Album'],
+ * geldig AS2 en werkelijk allebei, en een lezer die `type` als tekst uitpakt
+ * (Shaer doet dat) verloor daarmee stil het hele object.
+ */
+export function buildMixtapeObject(base, site, pl, rows) {
+  if (!pl) return null;
+  const abs = (u) => !u ? null : (/^https?:/i.test(u) ? u : `${base}${u.startsWith('/') ? '' : '/'}${u}`);
+  const postDatum = (pl._post && pl._post.uit_wanneer) ? new Date(pl._post.uit_wanneer) : null;
+  const wanneer = postDatum ? postDatum.toISOString()
+    : (pl.created_at ? new Date(pl.created_at).toISOString() : null);
+  // Dezelfde lening als bij het album: de post die het bandje uitbrengt geeft
+  // zijn titel, en de eigen titel blijft als alsoKnownAs staan.
+  const titel = (pl._post && pl._post.title) || pl.title;
+  const items = (rows || []).map((r) => buildTrackAudio(base, site, r, { coverFallback: pl.cover_url || null }));
+  const tape = {
+    type: 'Mixtape',
+    id: `${actorId(base, site.slug)}/playlists/${pl.id}`,
+    name: titel,
+    ...(wanneer ? { published: wanneer } : {}),
+    attributedTo: actorId(base, site.slug),
+    artist_credit: artistCredit(base, site, pl.artist, wanneer || new Date().toISOString()),
+    // De kant die het bandje maakt: eerst dit nummer, dan dat. Vooruit en
+    // achteruit is de speler; de volgorde is het object.
+    totalItems: items.length,
+    orderedItems: items,
+  };
+  if (titel !== pl.title) tape.alsoKnownAs = pl.title;
+  // De speelduur van het geheel, want dat is wat een bandje heeft: een lengte.
+  // Alleen als we van ELK nummer de duur kennen -- een som met gaten erin is
+  // een verzonnen getal, en die zetten we hier niet neer (zelfde regel als bij
+  // de bitrate van een track).
+  const duren = (rows || []).map((r) => Number(r.duration) || 0);
+  if (duren.length && duren.every((d) => d > 0)) {
+    tape.duration = `PT${Math.round(duren.reduce((a, b) => a + b, 0))}S`;
+  }
+  const hoes = abs(pl.cover_url || null);
+  if (hoes) tape.image = { type: 'Image', mediaType: guessMediaType(hoes), url: hoes };
+  return tape;
+}
+
 export function buildAlbumObject(base, site, pl) {
   if (!pl) return null;
@@ -580 +638 @@
   // album, dan leest hij deze velden gewoon. En het object dat hij echt gebruikt
   // staat toch al ingesloten op de track.
-  if ((playlist.kind || 'album') === 'album') {
+  const soort = SOORTEN.includes(playlist.kind) ? playlist.kind : 'album';
+  if (soort === 'album') {
     const album = buildAlbumObject(base, site, { ...playlist, _post: post });
     for (const veld of ['published', 'released', 'musicbrainzId', 'artist_credit', 'image']) {
       if (album[veld] !== undefined) out[veld] = album[veld];
+    }
+  }
+  // Een mixtape draagt hier zijn eigen velden, om dezelfde reden als het album:
+  // dit adres is waar een lezer terechtkomt die het bandje wil ophalen, en dan
+  // hoort er hetzelfde te staan als in het ingesloten object. `type` blijft ook
+  // hier OrderedCollection -- zie de uitleg hierboven over Shaer.
+  if (soort === 'mixtape') {
+    const tape = buildMixtapeObject(base, site, { ...playlist, _post: post }, rows);
+    for (const veld of ['published', 'artist_credit', 'image', 'duration', 'alsoKnownAs']) {
+      if (tape[veld] !== undefined) out[veld] = tape[veld];
     }
   }
@@ -801 +870 @@
 
 /**
- * De gekozen soort van een playlist: 'album' | 'playlist', of null als hij niet
- * (op deze site) bestaat. Zelfde normalisatie als PlaylistService: alles wat
- * geen 'playlist' zegt is een album.
+ * De gekozen soort van een playlist: 'album' | 'playlist' | 'mixtape', of null
+ * als hij niet (op deze site) bestaat. Zelfde lijst als PlaylistService, via
+ * de gedeelde pure module -- alles wat er niet in staat is een album.
  */
 function playlistKind(id, siteId) {
@@ -810 +879 @@
     const r = db.prepare('SELECT kind FROM playlists WHERE id = ? AND site_id = ?').get(id, siteId);
     if (!r) return null;
-    return r.kind === 'playlist' ? 'playlist' : 'album';
+    return SOORTEN.includes(r.kind) ? r.kind : 'album';
   } catch { return null; }
 }