From 0cdff63c35adc79f618bbecc189a36f34918ee0f Mon Sep 17 00:00:00 2001
From: Steven Vandevelde <steven@tokono.ma>
Date: Wed, 2 Jul 2025 14:37:30 +0200
Subject: [PATCH] fix: only save tracks when changed

---
 .../orchestrator/input-cache/_applet.astro     | 18 ++++++++----------
 .../output/storacha-automerge/_applet.astro    |  4 ++--
 src/scripts/input/opensubsonic/worker.ts       | 18 ++++++++++++------
 src/scripts/output/common.ts                   | 14 +++++++++++---
 4 files changed, 33 insertions(+), 21 deletions(-)

diff --git a/src/pages/orchestrator/input-cache/_applet.astro b/src/pages/orchestrator/input-cache/_applet.astro
index b8a86d3..c849c69 100644
--- a/src/pages/orchestrator/input-cache/_applet.astro
+++ b/src/pages/orchestrator/input-cache/_applet.astro
@@ -1,6 +1,7 @@
 <script>
   import type { ManagedOutput, ResolvedUri, Track } from "@applets/core/types.d.ts";
   import { applet, register, wait } from "@scripts/applet/common";
+  import { tracksCacheId } from "@scripts/output/common";
 
   ////////////////////////////////////////////
   // SETUP
@@ -23,11 +24,11 @@
   };
 
   // Start processing once settled and tracks are loaded
-  // context
-  //   .settled()
-  //   .then(() => configurator.output)
-  //   .then((output) => wait(output, (d) => d?.tracks.state === "loaded"))
-  //   .then(() => (context.isMainInstance() ? process() : undefined));
+  context
+    .settled()
+    .then(() => configurator.output)
+    .then((output) => wait(output, (d) => d?.tracks.state === "loaded"))
+    .then(() => (context.isMainInstance() ? process() : undefined));
 
   ////////////////////////////////////////////
   // ACTIONS
@@ -53,8 +54,6 @@
     });
 
     // Process
-    let changed = true; // TODO
-
     const tracksWithMetadata = await tracks.reduce(
       async (promise: Promise<Track[]>, track: Track) => {
         const acc = await promise;
@@ -88,15 +87,14 @@
           },
         );
 
-        console.log(stats, tags);
-        changed = true;
-
         return [...acc, { ...track, stats, tags }];
       },
       Promise.resolve([]),
     );
 
     // Save
+    const changed = tracksCacheId(tracksWithMetadata) !== output.data.tracks.cacheId;
+
     if (changed)
       await output.sendAction("tracks", tracksWithMetadata, {
         timeoutDuration: 60000 * 5,
diff --git a/src/pages/output/storacha-automerge/_applet.astro b/src/pages/output/storacha-automerge/_applet.astro
index 63bd7d7..f1dd698 100644
--- a/src/pages/output/storacha-automerge/_applet.astro
+++ b/src/pages/output/storacha-automerge/_applet.astro
@@ -5,7 +5,7 @@
 
   import type { ManagedOutput, Track } from "@applets/core/types.d.ts";
   import { register } from "@scripts/applet/common";
-  import { INITIAL_MANAGED_OUTPUT } from "@scripts/output/common";
+  import { INITIAL_MANAGED_OUTPUT, tracksCacheId } from "@scripts/output/common";
   import { cleanUndefinedValuesForTracks } from "@scripts/common";
 
   ////////////////////////////////////////////
@@ -61,7 +61,7 @@
         tracks: {
           ...context.data.tracks,
           ...trackDocument,
-          cacheId: crypto.randomUUID(),
+          cacheId: tracksCacheId(context.data.tracks.collection),
           state: "loaded",
         },
       };
diff --git a/src/scripts/input/opensubsonic/worker.ts b/src/scripts/input/opensubsonic/worker.ts
index 54d3d05..e064b05 100644
--- a/src/scripts/input/opensubsonic/worker.ts
+++ b/src/scripts/input/opensubsonic/worker.ts
@@ -1,6 +1,5 @@
 import { SubsonicAPI, type Child } from "subsonic-api";
 import * as URI from "uri-js";
-import QS from "query-string";
 
 import type { Consult, ConsultGrouping, GroupConsult, Track } from "@applets/core/types.d.ts";
 import { SCHEME } from "./constants.ts";
@@ -72,10 +71,10 @@ async function list(cachedTracks: Track[] = []) {
     const parsed = parseURI(t.uri);
     if (!parsed || !parsed.path) return acc;
 
-    const bid = serverId(parsed?.server);
-    const trk = { [parsed.path]: t };
+    const sid = serverId(parsed?.server);
+    const trk = { [URI.unescapeComponent(parsed.path)]: t };
 
-    return { ...acc, [bid]: acc[bid] ? { ...acc[bid], ...trk } : trk };
+    return { ...acc, [sid]: acc[sid] ? { ...acc[sid], ...trk } : trk };
   }, {});
 
   async function search(client: SubsonicAPI, offset = 0): Promise<Child[]> {
@@ -100,17 +99,24 @@ async function list(cachedTracks: Track[] = []) {
   const servers = await loadServers();
   const promises = Object.values(servers).map(async (server) => {
     const client = createClient(server);
+    const sid = serverId(server);
     const list = await search(client, 0);
 
     return list
       .filter((song) => !song.isVideo)
       .map((song) => {
-        if (song.path && cache[song.path]) return cache[song.path];
+        const path = song.path
+          ? song.path.startsWith("/")
+            ? song.path
+            : `/${song.path}`
+          : undefined;
+        const fromCache = path ? cache[sid]?.[path] : undefined;
+        if (fromCache) return fromCache;
 
         const track: Track = {
           id: crypto.randomUUID(),
           kind: autoTypeToTrackKind(song.type),
-          uri: buildURI(server, { songId: song.id, path: song.path }),
+          uri: buildURI(server, { songId: song.id, path }),
 
           stats: {
             bitrate: song.bitRate,
diff --git a/src/scripts/output/common.ts b/src/scripts/output/common.ts
index 667318a..44ad21b 100644
--- a/src/scripts/output/common.ts
+++ b/src/scripts/output/common.ts
@@ -1,9 +1,12 @@
+import { xxh32r } from "xxh32/dist/raw.js";
+
 import type { ManagedOutput, Track } from "@applets/core/types";
 import type { BroadcastedApplet } from "@scripts/applet/common";
+import { jsonEncode } from "@scripts/common";
 
 export const INITIAL_MANAGED_OUTPUT: ManagedOutput = {
   tracks: {
-    cacheId: crypto.randomUUID(),
+    cacheId: tracksCacheId([]),
     state: "loading",
     collection: [],
   },
@@ -32,7 +35,7 @@ export function outputManager<DataType>(args: {
     context.data = {
       ...context.data,
       tracks: {
-        cacheId: crypto.randomUUID(),
+        cacheId: tracksCacheId(collection),
         state: "loaded",
         collection,
       },
@@ -49,7 +52,7 @@ export function outputManager<DataType>(args: {
       context.data = {
         ...context.data,
         tracks: {
-          cacheId: crypto.randomUUID(),
+          cacheId: tracksCacheId(tracks),
           state: "loaded",
           collection: tracks,
         },
@@ -67,3 +70,8 @@ export function outputManager<DataType>(args: {
     tracks,
   };
 }
+
+export function tracksCacheId(tracks: Track[]): string {
+  // TODO: Probably should work with encoded tracks directly?
+  return xxh32r(jsonEncode(tracks)).toString();
+}
-- 
2.51.2