alphatheta-connect 0.25.0 → 0.25.2

package/lib/db/getMetadata.d.ts

@@ -1,5 +1,6 @@
 import { Track } from "../entities";
 import LocalDatabase from "../localdb";
+import { DatabaseType } from "../localdb/database-adapter";
 import RemoteDatabase from "../remotedb";
 import { Device, DeviceID, MediaSlot, TrackType } from "../types";
 import { TelemetrySpan as Span } from "../utils/telemetry";
@@ -20,6 +21,12 @@ export interface Options {
      * The track id to retrieve metadata for
      */
     trackId: number;
+    /**
+     * The track's BPM as the player reports it in its status packet, when known.
+     * Used to check that the local database row for `trackId` is really the
+     * track the player is showing (see {@link LocalDatabase.findTrack}).
+     */
+    trackBPM?: number | null;
     /**
      * The Sentry transaction span
      */
@@ -43,9 +50,15 @@ export type LocalMiss =
 export type LocalResult = {
     track: Track;
     miss: null;
+    /**
+     * Set when the slot had to switch to its other database format to
+     * answer: the format it is now served from.
+     */
+    switchedTo: DatabaseType | null;
 } | {
     track: null;
     miss: LocalMiss;
+    switchedTo: null;
 };
 export declare function viaRemote(remote: RemoteDatabase, opts: Required<Options>): Promise<Track<import("../entities").EntityFK.WithRelations> | null>;
 export declare function viaLocal(local: LocalDatabase, device: Device, opts: Required<Options>): Promise<LocalResult>;

package/lib/index.js

@@ -1268,25 +1268,24 @@ async function viaRemote(remote, opts) {
     return track;
 }
 async function viaLocal(local, device, opts) {
-    const { deviceId, trackSlot, trackId } = opts;
+    const { deviceId, trackSlot, trackId, trackBPM } = opts;
     if (trackSlot !== types_1.MediaSlot.USB && trackSlot !== types_1.MediaSlot.SD) {
         throw new Error('Expected USB or SD slot for local database query');
     }
-    const adapter = await local.get(deviceId, trackSlot);
-    if (adapter === null) {
-        return { track: null, miss: 'no-database' };
+    const lookup = await local.findTrack(deviceId, trackSlot, trackId, { trackBPM });
+    if (lookup.adapter === null) {
+        return { track: null, miss: 'no-database', switchedTo: null };
     }
-    const dbTrack = adapter.findTrack(trackId);
-    if (dbTrack === null) {
-        return { track: null, miss: 'track-absent' };
+    if (lookup.track === null) {
+        return { track: null, miss: 'track-absent', switchedTo: null };
     }
-    const anlz = await (0, rekordbox_1.loadAnlz)(dbTrack, 'DAT', (0, utils_1.anlzLoader)({ device, slot: trackSlot }));
+    const anlz = await (0, rekordbox_1.loadAnlz)(lookup.track, 'DAT', (0, utils_1.anlzLoader)({ device, slot: trackSlot }));
     const track = {
-        ...dbTrack,
+        ...lookup.track,
         beatGrid: anlz.beatGrid,
         waveformHd: null,
     };
-    return { track, miss: null };
+    return { track, miss: null, switchedTo: lookup.switchedTo };
 }
 
 
@@ -1610,6 +1609,7 @@ class Database {
      * Retrieve metadata for a track on a specific device slot.
      */
     async getMetadata(opts) {
+        var _a;
         const { deviceId, trackType, trackSlot, span } = opts;
         const tx = span
             ? span.startChild({ op: 'dbGetMetadata' })
@@ -1617,7 +1617,7 @@ class Database {
         tx.setTag('deviceId', deviceId.toString());
         tx.setTag('trackType', (0, utils_1.getTrackTypeName)(trackType));
         tx.setTag('trackSlot', (0, utils_1.getSlotName)(trackSlot));
-        const callOpts = { ...opts, span: tx };
+        const callOpts = { ...opts, trackBPM: (_a = opts.trackBPM) !== null && _a !== void 0 ? _a : null, span: tx };
         const device = await __classPrivateFieldGet(this, _Database_deviceManager, "f").getDeviceEnsured(deviceId);
         if (device === null) {
             return null;
@@ -1630,6 +1630,12 @@ class Database {
         if (strategy === LookupStrategy.Local) {
             const local = await GetMetadata.viaLocal(__classPrivateFieldGet(this, _Database_localDatabase, "f"), device, callOpts);
             track = local.track;
+            if (local.switchedTo !== null) {
+                __classPrivateFieldGet(this, _Database_logger, "f").info(`Device ${deviceId} ${(0, utils_1.getSlotName)(trackSlot)} is now read from the ` +
+                    `${local.switchedTo === 'pdb' ? 'legacy PDB' : 'OneLibrary'} database: ` +
+                    `it is the one that holds track ${opts.trackId} as the player reports it ` +
+                    `(NP3-399)`);
+            }
             // A local miss used to end the lookup, so the DJ's track silently never
             // reached the overlay for the rest of the set (NP3-361). Say what was
             // missed, then give the CDJ's own database a chance to answer.
@@ -2220,7 +2226,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _LocalDatabase_hostDevice, _LocalDatabase_deviceManager, _LocalDatabase_statusEmitter, _LocalDatabase_emitter, _LocalDatabase_slotLocks, _LocalDatabase_dbs, _LocalDatabase_preference, _LocalDatabase_handleDeviceRemoved, _LocalDatabase_fetchFileWithFallback, _LocalDatabase_tryLoadOneLibrary, _LocalDatabase_loadPdbDatabase, _LocalDatabase_hydrateDatabase;
+var _LocalDatabase_instances, _LocalDatabase_hostDevice, _LocalDatabase_deviceManager, _LocalDatabase_statusEmitter, _LocalDatabase_emitter, _LocalDatabase_slotLocks, _LocalDatabase_dbs, _LocalDatabase_preference, _LocalDatabase_handleDeviceRemoved, _LocalDatabase_closeLoaded, _LocalDatabase_fetchFileWithFallback, _LocalDatabase_tryLoadOneLibrary, _LocalDatabase_loadPdbDatabase, _LocalDatabase_hydrateDatabase, _LocalDatabase_loadAlternate, _LocalDatabase_getItem;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const async_mutex_1 = __webpack_require__(/*! async-mutex */ "async-mutex");
 const onelibrary_connect_1 = __webpack_require__(/*! onelibrary-connect */ "onelibrary-connect");
@@ -2236,6 +2242,18 @@ const utils_1 = __webpack_require__(/*! src/utils */ "./src/utils/index.ts");
 const Telemetry = __importStar(__webpack_require__(/*! src/utils/telemetry */ "./src/utils/telemetry.ts"));
 const orm_1 = __webpack_require__(/*! ./orm */ "./src/localdb/orm.ts");
 const rekordbox_1 = __webpack_require__(/*! ./rekordbox */ "./src/localdb/rekordbox.ts");
+/**
+ * A row is only trusted when the player's reported BPM agrees with it. Either
+ * side missing (unanalysed track, or a player that reports no BPM) is
+ * inconclusive and counts as agreement.
+ */
+const trackAgreesWithPlayer = (track, hint) => {
+    const reported = hint.trackBPM;
+    if (reported === null || reported === undefined || !track.tempo) {
+        return true;
+    }
+    return Math.abs(track.tempo - reported) < 0.05;
+};
 /**
  * Compute the identifier for media device in a CDJ. This is used to determine
  * if we have already hydrated the device or not into our local database.
@@ -2262,6 +2280,7 @@ const getMediaId = (info) => {
  */
 class LocalDatabase {
     constructor(hostDevice, deviceManager, statusEmitter, preference = 'auto') {
+        _LocalDatabase_instances.add(this);
         _LocalDatabase_hostDevice.set(this, void 0);
         _LocalDatabase_deviceManager.set(this, void 0);
         _LocalDatabase_statusEmitter.set(this, void 0);
@@ -2293,19 +2312,25 @@ class LocalDatabase {
         _LocalDatabase_handleDeviceRemoved.set(this, (device) => {
             const db = __classPrivateFieldGet(this, _LocalDatabase_dbs, "f").find(db => db.media.deviceId === device.id);
             if (db) {
-                db.adapter.close();
-                // Clean up temp file if it exists (OneLibrary databases)
-                if (db.tempFile) {
-                    try {
-                        fs.unlinkSync(db.tempFile);
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
+                __classPrivateFieldGet(this, _LocalDatabase_closeLoaded, "f").call(this, db);
+                if (db.alternate) {
+                    __classPrivateFieldGet(this, _LocalDatabase_closeLoaded, "f").call(this, db.alternate);
                 }
             }
             __classPrivateFieldSet(this, _LocalDatabase_dbs, __classPrivateFieldGet(this, _LocalDatabase_dbs, "f").filter(db => db.media.deviceId !== device.id), "f");
         });
+        _LocalDatabase_closeLoaded.set(this, (loaded) => {
+            loaded.adapter.close();
+            // Clean up temp file if it exists (OneLibrary databases)
+            if (loaded.tempFile) {
+                try {
+                    fs.unlinkSync(loaded.tempFile);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+        });
         /**
          * Helper to fetch a file from device, trying both dotted and non-dotted paths
          */
@@ -2412,11 +2437,54 @@ class LocalDatabase {
                 }
             }
             __classPrivateFieldGet(this, _LocalDatabase_emitter, "f").emit('hydrationDone', { device, slot });
-            const db = { adapter, media, id: getMediaId(media), tempFile };
+            const db = {
+                adapter,
+                media,
+                device,
+                slot,
+                id: getMediaId(media),
+                tempFile,
+                alternateLock: new async_mutex_1.Mutex(),
+            };
             __classPrivateFieldGet(this, _LocalDatabase_dbs, "f").push(db);
             tx.finish();
             return db;
         });
+        /**
+         * Loads the database format the slot is *not* currently served from, so a
+         * lookup can be checked against it. Only meaningful under the 'auto'
+         * preference: a forced format has no alternate. The result (or its absence)
+         * is remembered so the media is never downloaded twice.
+         */
+        _LocalDatabase_loadAlternate.set(this, (db) => db.alternateLock.runExclusive(async () => {
+            if (db.alternate !== undefined) {
+                return db.alternate;
+            }
+            if (__classPrivateFieldGet(this, _LocalDatabase_preference, "f") !== 'auto') {
+                db.alternate = null;
+                return null;
+            }
+            const tx = Telemetry.startTransaction({ name: 'hydrateAlternateDatabase' });
+            tx.setTag('slot', (0, utils_1.getSlotName)(db.media.slot));
+            tx.setTag('activeDbType', db.adapter.type);
+            try {
+                if (db.adapter.type === 'oneLibrary') {
+                    const adapter = await __classPrivateFieldGet(this, _LocalDatabase_loadPdbDatabase, "f").call(this, db.device, db.slot, tx);
+                    db.alternate = { adapter };
+                    tx.setTag('dbType', 'pdb');
+                }
+                else {
+                    db.alternate = await __classPrivateFieldGet(this, _LocalDatabase_tryLoadOneLibrary, "f").call(this, db.device, db.slot, tx);
+                    tx.setTag('dbType', db.alternate ? 'oneLibrary' : 'none');
+                }
+            }
+            catch {
+                // The media simply has no such file (or it could not be read).
+                db.alternate = null;
+            }
+            tx.finish();
+            return db.alternate;
+        }));
         __classPrivateFieldSet(this, _LocalDatabase_hostDevice, hostDevice, "f");
         __classPrivateFieldSet(this, _LocalDatabase_deviceManager, deviceManager, "f");
         __classPrivateFieldSet(this, _LocalDatabase_statusEmitter, statusEmitter, "f");
@@ -2441,6 +2509,45 @@ class LocalDatabase {
     disconnectForDevice(device) {
         __classPrivateFieldGet(this, _LocalDatabase_handleDeviceRemoved, "f").call(this, device);
     }
+    /**
+     * Looks a track up in the databases of a device slot, checking the answer
+     * against what the player reports.
+     *
+     * A Device Library Plus export carries both `exportLibrary.db` and the
+     * legacy `export.pdb`, and their track IDs are different number spaces. A
+     * player that reads one while we loaded the other resolves most IDs to a
+     * different track and some to nothing at all (NP3-399). So when the active
+     * database has no such row, or its row's BPM is not the BPM the player is
+     * showing, the other format is loaded and asked. If it agrees with the
+     * player, the slot switches to it for every later lookup — artwork,
+     * analysis and the next track all follow the database the player is using.
+     *
+     * When neither database can be confirmed, the active database's row (if any)
+     * is returned as before.
+     */
+    async findTrack(deviceId, slot, trackId, hint = {}) {
+        const db = await __classPrivateFieldGet(this, _LocalDatabase_instances, "m", _LocalDatabase_getItem).call(this, deviceId, slot);
+        if (db === null) {
+            return { adapter: null, track: null, switchedTo: null };
+        }
+        const active = db.adapter.findTrack(trackId);
+        if (active !== null && trackAgreesWithPlayer(active, hint)) {
+            return { adapter: db.adapter, track: active, switchedTo: null };
+        }
+        const alternate = await __classPrivateFieldGet(this, _LocalDatabase_loadAlternate, "f").call(this, db);
+        if (alternate !== null) {
+            const other = alternate.adapter.findTrack(trackId);
+            if (other !== null && trackAgreesWithPlayer(other, hint)) {
+                db.alternate = { adapter: db.adapter, tempFile: db.tempFile };
+                db.adapter = alternate.adapter;
+                db.tempFile = alternate.tempFile;
+                return { adapter: db.adapter, track: other, switchedTo: db.adapter.type };
+            }
+        }
+        return active === null
+            ? { adapter: db.adapter, track: null, switchedTo: null }
+            : { adapter: db.adapter, track: active, switchedTo: null };
+    }
     /**
      * Gets the database adapter for the media metadata in the provided device slot.
      *
@@ -2451,43 +2558,8 @@ class LocalDatabase {
      */
     async get(deviceId, slot) {
         var _a;
-        const lockKey = `${deviceId}-${slot}`;
-        const lock = (_a = __classPrivateFieldGet(this, _LocalDatabase_slotLocks, "f").get(lockKey)) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _LocalDatabase_slotLocks, "f").set(lockKey, new async_mutex_1.Mutex()).get(lockKey);
-        const device = __classPrivateFieldGet(this, _LocalDatabase_deviceManager, "f").devices.get(deviceId);
-        if (device === undefined) {
-            return null;
-        }
-        if (device.type !== types_1.DeviceType.CDJ ||
-            device.id < constants_1.MIN_CDJ_DEVICE_ID ||
-            device.id > constants_1.MAX_CDJ_DEVICE_ID) {
-            return null;
-        }
-        let media;
-        try {
-            media = await __classPrivateFieldGet(this, _LocalDatabase_statusEmitter, "f").queryMediaSlot({
-                hostDevice: __classPrivateFieldGet(this, _LocalDatabase_hostDevice, "f"),
-                device,
-                slot,
-            });
-        }
-        catch {
-            // Timeout or other error - treat as no media
-            return null;
-        }
-        if (media.tracksType !== types_1.TrackType.RB) {
-            return null;
-        }
-        const id = getMediaId(media);
-        // Acquire a lock for this device slot that will not release until we've
-        // guaranteed the existence of the database.
-        const db = await lock.runExclusive(() => {
-            const cached = __classPrivateFieldGet(this, _LocalDatabase_dbs, "f").find(db => db.id === id);
-            if (cached) {
-                return cached;
-            }
-            return __classPrivateFieldGet(this, _LocalDatabase_hydrateDatabase, "f").call(this, device, slot, media);
-        });
-        return db.adapter;
+        const db = await __classPrivateFieldGet(this, _LocalDatabase_instances, "m", _LocalDatabase_getItem).call(this, deviceId, slot);
+        return (_a = db === null || db === void 0 ? void 0 : db.adapter) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * Get the database type for an already-loaded device slot.
@@ -2513,7 +2585,50 @@ class LocalDatabase {
         await Promise.all(loaders);
     }
 }
-_LocalDatabase_hostDevice = new WeakMap(), _LocalDatabase_deviceManager = new WeakMap(), _LocalDatabase_statusEmitter = new WeakMap(), _LocalDatabase_emitter = new WeakMap(), _LocalDatabase_slotLocks = new WeakMap(), _LocalDatabase_dbs = new WeakMap(), _LocalDatabase_preference = new WeakMap(), _LocalDatabase_handleDeviceRemoved = new WeakMap(), _LocalDatabase_fetchFileWithFallback = new WeakMap(), _LocalDatabase_tryLoadOneLibrary = new WeakMap(), _LocalDatabase_loadPdbDatabase = new WeakMap(), _LocalDatabase_hydrateDatabase = new WeakMap();
+_LocalDatabase_hostDevice = new WeakMap(), _LocalDatabase_deviceManager = new WeakMap(), _LocalDatabase_statusEmitter = new WeakMap(), _LocalDatabase_emitter = new WeakMap(), _LocalDatabase_slotLocks = new WeakMap(), _LocalDatabase_dbs = new WeakMap(), _LocalDatabase_preference = new WeakMap(), _LocalDatabase_handleDeviceRemoved = new WeakMap(), _LocalDatabase_closeLoaded = new WeakMap(), _LocalDatabase_fetchFileWithFallback = new WeakMap(), _LocalDatabase_tryLoadOneLibrary = new WeakMap(), _LocalDatabase_loadPdbDatabase = new WeakMap(), _LocalDatabase_hydrateDatabase = new WeakMap(), _LocalDatabase_loadAlternate = new WeakMap(), _LocalDatabase_instances = new WeakSet(), _LocalDatabase_getItem = 
+/**
+ * The loaded database entry for a device slot, hydrating it first if needed.
+ */
+async function _LocalDatabase_getItem(deviceId, slot) {
+    var _a;
+    const lockKey = `${deviceId}-${slot}`;
+    const lock = (_a = __classPrivateFieldGet(this, _LocalDatabase_slotLocks, "f").get(lockKey)) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _LocalDatabase_slotLocks, "f").set(lockKey, new async_mutex_1.Mutex()).get(lockKey);
+    const device = __classPrivateFieldGet(this, _LocalDatabase_deviceManager, "f").devices.get(deviceId);
+    if (device === undefined) {
+        return null;
+    }
+    if (device.type !== types_1.DeviceType.CDJ ||
+        device.id < constants_1.MIN_CDJ_DEVICE_ID ||
+        device.id > constants_1.MAX_CDJ_DEVICE_ID) {
+        return null;
+    }
+    let media;
+    try {
+        media = await __classPrivateFieldGet(this, _LocalDatabase_statusEmitter, "f").queryMediaSlot({
+            hostDevice: __classPrivateFieldGet(this, _LocalDatabase_hostDevice, "f"),
+            device,
+            slot,
+        });
+    }
+    catch {
+        // Timeout or other error - treat as no media
+        return null;
+    }
+    if (media.tracksType !== types_1.TrackType.RB) {
+        return null;
+    }
+    const id = getMediaId(media);
+    // Acquire a lock for this device slot that will not release until we've
+    // guaranteed the existence of the database.
+    const db = await lock.runExclusive(() => {
+        const cached = __classPrivateFieldGet(this, _LocalDatabase_dbs, "f").find(db => db.id === id);
+        if (cached) {
+            return cached;
+        }
+        return __classPrivateFieldGet(this, _LocalDatabase_hydrateDatabase, "f").call(this, device, slot, media);
+    });
+    return db;
+};
 exports["default"] = LocalDatabase;