plexsonic 0.1.12 → 0.1.20

package/src/subsonic-xml.js

@@ -21,23 +21,61 @@
 import { APP_VERSION } from './version.js';
 
 const XML_HEADER = '<?xml version="1.0" encoding="UTF-8"?>';
+const ROOT_NAME = 'subsonic-response';
 const XMLNS = 'http://subsonic.org/restapi';
 const API_VERSION = '1.16.1';
 const SERVER_TYPE = 'Plexsonic';
 const SERVER_VERSION = APP_VERSION;
 const OPEN_SUBSONIC = true;
 
+const ROOT_ATTR_KEYS = new Set([
+  'status',
+  'version',
+  'type',
+  'serverVersion',
+  'openSubsonic',
+  'xmlns',
+]);
 
+const XML_ATTR_LIST_KEYS = new Set(['genres', 'moods', 'styles', 'recordLabels']);
 
-export function xmlEscape(value) {
-  const sanitized = sanitizeXmlText(String(value));
-  return sanitized
-    .replaceAll('&', '&amp;')
-    .replaceAll('<', '&lt;')
-    .replaceAll('>', '&gt;')
-    .replaceAll('"', '&quot;')
-    .replaceAll("'", '&apos;');
-}
+// Dedicated XML schema rules: these define repeated child elements by parent element.
+const ARRAY_CHILDREN_BY_PARENT = {
+  openSubsonicExtensions: new Set(['openSubsonicExtension']),
+  albumList: new Set(['album']),
+  albumList2: new Set(['album']),
+  artists: new Set(['index']),
+  indexes: new Set(['index']),
+  index: new Set(['artist']),
+  artist: new Set(['album']),
+  album: new Set(['song']),
+  albumArtists: new Set(['artist']),
+  songsByGenre: new Set(['song']),
+  randomSongs: new Set(['song']),
+  topSongs: new Set(['song']),
+  similarSongs: new Set(['song']),
+  similarSongs2: new Set(['song']),
+  searchResult: new Set(['artist', 'album', 'match']),
+  searchResult2: new Set(['artist', 'album', 'song']),
+  searchResult3: new Set(['artist', 'album', 'song']),
+  musicFolders: new Set(['musicFolder']),
+  genres: new Set(['genre']),
+  playlists: new Set(['playlist']),
+  directory: new Set(['child']),
+  playlist: new Set(['entry']),
+  playQueue: new Set(['entry']),
+  nowPlaying: new Set(['entry']),
+  lyricsList: new Set(['structuredLyrics']),
+  structuredLyrics: new Set(['line']),
+  starred: new Set(['artist', 'album', 'song']),
+  starred2: new Set(['artist', 'album', 'song']),
+};
+
+// Dedicated scalar-child rules for XML where values should be child elements, not attributes.
+const SCALAR_CHILDREN_BY_PARENT = {
+  artistInfo: new Set(['biography', 'musicBrainzId']),
+  artistInfo2: new Set(['biography', 'musicBrainzId']),
+};
 
 function sanitizeXmlText(value) {
   let output = '';
@@ -57,328 +95,263 @@ function sanitizeXmlText(value) {
   return output;
 }
 
-function normalizeChildren(input) {
-  if (input == null || input === '') {
-    return [];
-  }
-  if (Array.isArray(input)) {
-    return input.flatMap((item) => normalizeChildren(item));
-  }
-  if (typeof input === 'object' && input.kind === 'node') {
-    return [input];
+export function xmlEscape(value) {
+  const sanitized = sanitizeXmlText(String(value));
+  return sanitized
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+}
+
+function splitList(rawValue) {
+  if (Array.isArray(rawValue)) {
+    return rawValue.map((entry) => String(entry || '').trim()).filter(Boolean);
   }
-  if (typeof input === 'string') {
-    return [input];
+
+  const raw = String(rawValue || '').trim();
+  if (!raw) {
+    return [];
   }
-  return [String(input)];
-}
 
-function xmlAttrs(attrs = {}) {
-  return Object.entries(attrs)
-    .filter(([, value]) => value !== undefined && value !== null)
-    .map(([key, value]) => ` ${key}="${xmlEscape(value)}"`)
-    .join('');
+  const parts = raw.includes(';') ? raw.split(';') : raw.split(',');
+  return parts.map((part) => part.trim()).filter(Boolean);
 }
 
-function renderXmlPart(part) {
-  if (typeof part === 'string') {
-    return xmlEscape(part);
-  }
-  if (!part || part.kind !== 'node') {
-    return '';
+function toXmlAttrValue(key, value) {
+  if (value === undefined || value === null) {
+    return null;
   }
 
-  const attrs = xmlAttrs(part.attrs);
-  if (part.selfClosing && part.children.length === 0) {
-    return `<${part.name}${attrs}/>`;
+  if (key === 'genres' || key === 'recordLabels') {
+    const names = Array.isArray(value)
+      ? value
+        .map((entry) => {
+          if (entry && typeof entry === 'object') {
+            return String(entry.name || '').trim();
+          }
+          return String(entry || '').trim();
+        })
+        .filter(Boolean)
+      : splitList(value);
+    return names.join('; ');
   }
 
-  const inner = part.children.map(renderXmlPart).join('');
-  return `<${part.name}${attrs}>${inner}</${part.name}>`;
-}
-
+  if (key === 'moods' || key === 'styles') {
+    return splitList(value).join('; ');
+  }
 
+  if (Array.isArray(value)) {
+    return value.map((entry) => String(entry)).join(',');
+  }
 
-const NUMERIC_ATTRS = new Set([
-  'code',
-  'count',
-  'offset',
-  'duration',
-  'songCount',
-  'albumCount',
-  'track',
-  'discNumber',
-  'bitRate',
-  'size',
-  'year',
-  'userRating',
-  'playCount',
-  'leafCount',
-  'leafCountAdded',
-  'leafCountRequested',
-  'position',
-  'lastModified',
-  'start',
-  'sampleRate',
-  'bitDepth',
-]);
+  if (typeof value === 'boolean') {
+    return value ? 'true' : 'false';
+  }
 
-const BOOLEAN_ATTRS = new Set([
-  'openSubsonic',
-  'valid',
-  'scanning',
-  'isDir',
-  'public',
-  'scrobblingEnabled',
-  'adminRole',
-  'settingsRole',
-  'downloadRole',
-  'uploadRole',
-  'playlistRole',
-  'coverArtRole',
-  'commentRole',
-  'podcastRole',
-  'streamRole',
-  'jukeboxRole',
-  'shareRole',
-  'videoConversionRole',
-  'smart',
-  'synced',
-  'readonly',
-  'compilation',
-  'soundtrack',
-]);
+  return String(value);
+}
 
-const ARRAY_CHILDREN_BY_PARENT = {
-  openSubsonicExtensions: new Set(['openSubsonicExtension']),
-  albumList: new Set(['album']),
-  albumList2: new Set(['album']),
-  artists: new Set(['index']),
-  indexes: new Set(['index']),
-  index: new Set(['artist']),
-  artist: new Set(['album']),
-  album: new Set(['song']),
-  albumArtists: new Set(['artist']),
-  songsByGenre: new Set(['song']),
-  randomSongs: new Set(['song']),
-  topSongs: new Set(['song']),
-  searchResult: new Set(['artist', 'album', 'match']),
-  searchResult2: new Set(['artist', 'album', 'song']),
-  searchResult3: new Set(['artist', 'album', 'song']),
-  musicFolders: new Set(['musicFolder']),
-  genres: new Set(['genre']),
-  playlists: new Set(['playlist']),
-  directory: new Set(['child']),
-  playlist: new Set(['entry']),
-  playQueue: new Set(['entry']),
-  nowPlaying: new Set(['entry']),
-  lyricsList: new Set(['structuredLyrics']),
-  structuredLyrics: new Set(['line']),
-  starred: new Set(['artist', 'album', 'song']),
-  starred2: new Set(['artist', 'album', 'song']),
-};
+function xmlAttrs(attrs = {}) {
+  return Object.entries(attrs)
+    .map(([key, value]) => {
+      const attrValue = toXmlAttrValue(key, value);
+      if (attrValue == null) {
+        return '';
+      }
+      return ` ${key}="${xmlEscape(attrValue)}"`;
+    })
+    .join('');
+}
 
 function shouldUseArray(parentName, childName) {
   return ARRAY_CHILDREN_BY_PARENT[parentName]?.has(childName) || false;
 }
 
-function coerceAttrValue(key, value) {
-  const splitList = (rawValue) => {
-    if (Array.isArray(rawValue)) {
-      return rawValue.map((entry) => String(entry || '').trim()).filter(Boolean);
-    }
-    const raw = String(rawValue || '').trim();
-    if (!raw) {
-      return [];
-    }
-    const parts = raw.includes(';') ? raw.split(';') : raw.split(',');
-    return parts.map((part) => part.trim()).filter(Boolean);
-  };
+function isScalarChild(parentName, childName) {
+  return SCALAR_CHILDREN_BY_PARENT[parentName]?.has(childName) || false;
+}
 
-  if (key === 'genres') {
-    const genreNames = splitList(value);
-    return genreNames.map((name) => ({ name }));
+function defaultArrayChildName(parentName) {
+  const children = ARRAY_CHILDREN_BY_PARENT[parentName];
+  if (!children || children.size !== 1) {
+    return null;
   }
+  return [...children][0];
+}
 
-  if (key === 'moods') {
-    return splitList(value);
+function isFlattenArtistList(name, value) {
+  if ((name !== 'artists' && name !== 'albumArtists') || !Array.isArray(value)) {
+    return false;
+  }
+  if (value.length === 0) {
+    return true;
   }
+  return value.every((entry) => entry && typeof entry === 'object' && !Array.isArray(entry));
+}
 
-  if (key === 'styles') {
-    return splitList(value);
+function shouldRenderAsChild(parentName, key, value) {
+  if (parentName === ROOT_NAME) {
+    return !ROOT_ATTR_KEYS.has(key);
   }
 
-  if (key === 'recordLabels') {
-    const labels = splitList(value);
-    return labels.map((name) => ({ name }));
+  if (key === 'value') {
+    return false;
   }
 
-  if (BOOLEAN_ATTRS.has(key)) {
-    if (value === 'true') {
-      return true;
-    }
-    if (value === 'false') {
-      return false;
-    }
+  if (isScalarChild(parentName, key)) {
+    return true;
   }
 
-  if (NUMERIC_ATTRS.has(key) && /^-?\d+$/.test(String(value))) {
-    return Number(value);
+  if (shouldUseArray(parentName, key)) {
+    return true;
   }
 
-  return value;
+  if (XML_ATTR_LIST_KEYS.has(key)) {
+    return false;
+  }
+
+  if (Array.isArray(value)) {
+    return value.some((entry) => entry && typeof entry === 'object');
+  }
+
+  return Boolean(value && typeof value === 'object');
 }
 
-function nodeToJson(node) {
-  const out = {};
-  for (const [key, value] of Object.entries(node.attrs || {})) {
-    out[key] = coerceAttrValue(key, value);
+function renderXmlElement(name, value) {
+  if (value === undefined || value === null) {
+    return `<${name}/>`;
   }
 
-  for (const child of node.children || []) {
-    if (typeof child === 'string') {
-      if (child.trim()) {
-        out.value = (out.value || '') + child;
-      }
+  if (typeof value !== 'object') {
+    return `<${name}>${xmlEscape(value)}</${name}>`;
+  }
+
+  if (Array.isArray(value)) {
+    const childName =
+      (name === 'artists' || name === 'albumArtists')
+        ? 'artist'
+        : defaultArrayChildName(name);
+    const attrs = isFlattenArtistList(name, value) ? { flatten: 'true' } : {};
+
+    if (!childName) {
+      const text = value.map((entry) => String(entry)).join(', ');
+      return `<${name}${xmlAttrs(attrs)}>${xmlEscape(text)}</${name}>`;
+    }
+
+    const inner = value.map((entry) => renderXmlElement(childName, entry)).join('');
+    if (!inner) {
+      return `<${name}${xmlAttrs(attrs)}/>`;
+    }
+
+    return `<${name}${xmlAttrs(attrs)}>${inner}</${name}>`;
+  }
+
+  const attrs = {};
+  let textValue = '';
+  const childParts = [];
+
+  for (const [key, childValue] of Object.entries(value)) {
+    if (key === 'value') {
+      textValue += String(childValue || '');
       continue;
     }
 
-    const value = nodeToJson(child);
-    if (shouldUseArray(node.name, child.name)) {
-      if (!Array.isArray(out[child.name])) {
-        out[child.name] = [];
-      }
-      out[child.name].push(value);
+    if (!shouldRenderAsChild(name, key, childValue)) {
+      attrs[key] = childValue;
       continue;
     }
 
-    if (Object.prototype.hasOwnProperty.call(out, child.name)) {
-      if (!Array.isArray(out[child.name])) {
-        out[child.name] = [out[child.name]];
+    if (Array.isArray(childValue)) {
+      if (shouldUseArray(name, key)) {
+        for (const entry of childValue) {
+          childParts.push(renderXmlElement(key, entry));
+        }
+      } else {
+        childParts.push(renderXmlElement(key, childValue));
       }
-      out[child.name].push(value);
       continue;
     }
 
-    out[child.name] = value;
+    childParts.push(renderXmlElement(key, childValue));
   }
 
-  const arrayChildren = ARRAY_CHILDREN_BY_PARENT[node.name];
-  if (arrayChildren) {
-    for (const childName of arrayChildren) {
-      if (!Object.prototype.hasOwnProperty.call(out, childName)) {
-        out[childName] = [];
-      }
-    }
+  const inner = `${xmlEscape(textValue)}${childParts.join('')}`;
+  if (!inner) {
+    return `<${name}${xmlAttrs(attrs)}/>`;
   }
 
-  const keys = Object.keys(out);
-  if (keys.length === 1 && keys[0] === 'value') {
-    return out.value;
-  }
+  return `<${name}${xmlAttrs(attrs)}>${inner}</${name}>`;
+}
 
-  if (node.name === 'artists' || node.name === 'albumArtists') {
-    if (node.attrs?.flatten === 'true') {
-      const artistValue = out.artist;
-      if (Array.isArray(artistValue)) {
-        return artistValue;
-      }
-      if (artistValue != null) {
-        return [artistValue];
-      }
-      return [];
-    }
+function normalizeInner(inner) {
+  if (!inner || typeof inner !== 'object' || Array.isArray(inner)) {
+    return {};
   }
-
-  if (node.name === 'openSubsonicExtensions') {
-    const extensions = out.openSubsonicExtension;
-    if (Array.isArray(extensions)) {
-      return extensions;
+  const out = {};
+  for (const [key, value] of Object.entries(inner)) {
+    if (Array.isArray(value)) {
+      const childName = defaultArrayChildName(key);
+      if (childName && key !== 'artists' && key !== 'albumArtists') {
+        out[key] = { [childName]: value };
+      } else {
+        out[key] = value;
+      }
+      continue;
     }
-    return extensions == null ? [] : [extensions];
+    out[key] = value;
   }
-
   return out;
 }
 
-function subsonicRoot(status, children = []) {
+function buildRoot(status, inner = {}) {
   return {
-    kind: 'node',
-    name: 'subsonic-response',
-    selfClosing: false,
-    attrs: {
-      status,
-      version: API_VERSION,
-      type: SERVER_TYPE,
-      serverVersion: SERVER_VERSION,
-      openSubsonic: OPEN_SUBSONIC,
-      xmlns: XMLNS,
-    },
-    children,
+    status,
+    version: API_VERSION,
+    type: SERVER_TYPE,
+    serverVersion: SERVER_VERSION,
+    openSubsonic: OPEN_SUBSONIC,
+    ...normalizeInner(inner),
   };
 }
 
-export function emptyNode(name, attrs = {}) {
+export function okResponseJson(inner = {}) {
   return {
-    kind: 'node',
-    name,
-    attrs,
-    children: [],
-    selfClosing: true,
+    [ROOT_NAME]: buildRoot('ok', inner),
   };
 }
 
-export function node(name, attrs = {}, inner = null) {
+export function failedResponseJson(code, message) {
   return {
-    kind: 'node',
-    name,
-    attrs,
-    children: normalizeChildren(inner),
-    selfClosing: false,
+    [ROOT_NAME]: buildRoot('failed', {
+      error: {
+        code,
+        message: String(message),
+      },
+    }),
   };
 }
 
-export function okResponse(inner = '') {
-  const root = subsonicRoot('ok', normalizeChildren(inner));
-  return `${XML_HEADER}${renderXmlPart(root)}`;
-}
-
-export function failedResponse(code, message) {
-  const errorNode = {
-    kind: 'node',
-    name: 'error',
-    attrs: {
-      code,
-      message: String(message),
-    },
-    children: [],
-    selfClosing: true,
-  };
-  const root = subsonicRoot('failed', [errorNode]);
-  return `${XML_HEADER}${renderXmlPart(root)}`;
+export function subsonicJsonToXml(payload) {
+  const rootValue = payload?.[ROOT_NAME];
+  const safeRoot = rootValue && typeof rootValue === 'object' && !Array.isArray(rootValue)
+    ? rootValue
+    : buildRoot('failed', {
+      error: {
+        code: 0,
+        message: 'Invalid Subsonic payload',
+      },
+    });
+
+  const xmlRoot = safeRoot.xmlns ? safeRoot : { ...safeRoot, xmlns: XMLNS };
+  return `${XML_HEADER}${renderXmlElement(ROOT_NAME, xmlRoot)}`;
 }
 
-export function okResponseJson(inner = '') {
-  const root = subsonicRoot('ok', normalizeChildren(inner));
-  const json = nodeToJson(root);
-  delete json.xmlns;
-  return { 'subsonic-response': json };
+export function okResponse(inner = {}) {
+  return subsonicJsonToXml(okResponseJson(inner));
 }
 
-export function failedResponseJson(code, message) {
-  const errorNode = {
-    kind: 'node',
-    name: 'error',
-    attrs: {
-      code,
-      message: String(message),
-    },
-    children: [],
-    selfClosing: true,
-  };
-  const root = subsonicRoot('failed', [errorNode]);
-  const json = nodeToJson(root);
-  delete json.xmlns;
-  return { 'subsonic-response': json };
+export function failedResponse(code, message) {
+  return subsonicJsonToXml(failedResponseJson(code, message));
 }
-