@onpeek/nuvio 1.0.0

package/dist/nuvio/ops/library.js

@@ -0,0 +1,139 @@
+import { NuvioError } from '../errors.js';
+import { historyKeyOf, libraryKeyOf, progressKeyOf, storedProgressKey, } from '../keys.js';
+import { readAllLibrary, readAllWatchHistory, readAllWatchProgress } from './readers.js';
+import { planHistoryAdd, planHistoryDelete, planLibraryAdd, planLibraryRemove, planProgressDelete, planProgressSet, } from './transitions.js';
+export { progressKeyOf, historyKeyOf };
+export const historyKeyFrom = historyKeyOf;
+function nowSeconds() {
+    return Math.floor(Date.now() / 1000);
+}
+// ---------------------------------------------------------------------------
+// Reads (public list tools keep their own pagination shape)
+// ---------------------------------------------------------------------------
+export async function getLibrary(client, profileId, limit = 100, offset = 0) {
+    return client.readRpc('sync_pull_library', { p_profile_id: profileId, p_limit: limit, p_offset: offset });
+}
+export async function getWatchProgress(client, profileId, limit = 100) {
+    return client.readRpc('sync_pull_watch_progress', { p_profile_id: profileId, p_limit: limit });
+}
+export async function getWatchHistory(client, profileId, page = 1, pageSize = 100) {
+    return client.readRpc('sync_pull_watched_items', {
+        p_profile_id: profileId,
+        p_page: page,
+        p_page_size: pageSize,
+    });
+}
+// ---------------------------------------------------------------------------
+// Mutations (complete readers; deletes are not gated on a first page)
+// ---------------------------------------------------------------------------
+export async function addToLibrary(client, profileId, items, originId, apply, now = nowSeconds()) {
+    if (items.length === 0)
+        throw new NuvioError('At least one item is required');
+    const before = (await readAllLibrary(client, profileId));
+    const { after, diff } = planLibraryAdd(before, items, now);
+    if (apply && diff.length > 0) {
+        const pushes = after.filter((row) => {
+            const key = libraryKeyOf(row);
+            const prev = before.find((b) => libraryKeyOf(b) === key);
+            return !prev || JSON.stringify(prev) !== JSON.stringify(row);
+        });
+        await client.rpc('sync_push_library_items', {
+            p_profile_id: profileId,
+            p_items: pushes,
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply && diff.length > 0, changed: diff.length > 0, before, after, diff };
+}
+export async function removeFromLibrary(client, profileId, keys, originId, apply) {
+    if (keys.length === 0)
+        throw new NuvioError('At least one key is required');
+    const before = (await readAllLibrary(client, profileId));
+    const { after, diff } = planLibraryRemove(before, keys);
+    // Always send the delete for the provided keys — the backend is the source of
+    // truth, not the read page.
+    if (apply) {
+        await client.rpc('sync_delete_library_items', {
+            p_profile_id: profileId,
+            p_keys: keys,
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply, changed: keys.length > 0, before, after, diff };
+}
+export async function setWatchProgress(client, profileId, entries, originId, apply, now = nowSeconds()) {
+    if (entries.length === 0)
+        throw new NuvioError('At least one entry is required');
+    const before = (await readAllWatchProgress(client, profileId, { requireComplete: true }));
+    const { after, diff } = planProgressSet(before, entries, now);
+    if (apply && diff.length > 0) {
+        const pushes = after.filter((row) => {
+            const prev = before.find((b) => storedProgressKey(b) === storedProgressKey(row));
+            return !prev || JSON.stringify(prev) !== JSON.stringify(row);
+        });
+        await client.rpc('sync_push_watch_progress', {
+            p_profile_id: profileId,
+            p_entries: pushes,
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply && diff.length > 0, changed: diff.length > 0, before, after, diff };
+}
+export async function addToWatchHistory(client, profileId, items, originId, apply, now = nowSeconds()) {
+    if (items.length === 0)
+        throw new NuvioError('At least one item is required');
+    const before = (await readAllWatchHistory(client, profileId));
+    const { after, diff } = planHistoryAdd(before, items, now);
+    if (apply && diff.length > 0) {
+        const pushes = after.filter((row) => {
+            const prev = before.find((b) => historyKeyOf(b) === historyKeyOf(row));
+            return !prev || JSON.stringify(prev) !== JSON.stringify(row);
+        });
+        await client.rpc('sync_push_watched_items', {
+            p_profile_id: profileId,
+            p_items: pushes,
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply && diff.length > 0, changed: diff.length > 0, before, after, diff };
+}
+export async function deleteWatchProgress(client, profileId, keys, originId, apply) {
+    if (keys.length === 0)
+        throw new NuvioError('At least one key is required');
+    const before = (await readAllWatchProgress(client, profileId, { requireComplete: true }));
+    const { after, diff } = planProgressDelete(before, keys);
+    const wanted = new Set(keys.map((k) => progressKeyOf(k)));
+    const internalKeys = new Set();
+    for (const key of keys)
+        internalKeys.add(progressKeyOf(key));
+    for (const row of before) {
+        if (wanted.has(progressKeyOf(row)))
+            internalKeys.add(storedProgressKey(row));
+    }
+    if (apply) {
+        await client.rpc('sync_delete_watch_progress', {
+            p_profile_id: profileId,
+            p_keys: [...internalKeys],
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply, changed: keys.length > 0, before, after, diff };
+}
+export async function deleteWatchHistory(client, profileId, keys, originId, apply) {
+    if (keys.length === 0)
+        throw new NuvioError('At least one key is required');
+    const before = (await readAllWatchHistory(client, profileId));
+    const { after, diff } = planHistoryDelete(before, keys);
+    if (apply) {
+        await client.rpc('sync_delete_watched_items', {
+            p_profile_id: profileId,
+            p_keys: keys.map((k) => ({
+                content_id: k.content_id,
+                season: k.season ?? null,
+                episode: k.episode ?? null,
+            })),
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply, changed: keys.length > 0, before, after, diff };
+}