feat: removed sequelize/sqlite3 in favor of native node:sqlite

Author: rombat

lib/handlers/MBNDSynchronizer.js

@@ -1,91 +1,179 @@
-const { Sequelize } = require('sequelize');
-const TrackDefinition = require('../models/Track');
-const AlbumDefinition = require('../models/Album');
-const AnnotationDefinition = require('../models/Annotation');
-const ArtistDefinition = require('../models/Artist');
-const UserDefinition = require('../models/User');
-const MediaFileArtistDefinition = require('../models/MediaFileArtist');
-
-exports.init = async dbFilePath => {
-  const sequelize = new Sequelize({
-    dialect: 'sqlite',
-    storage: dbFilePath,
-    logging: !!process.env.DEBUG
-  });
-  try {
-    await sequelize.authenticate();
-    console.log('Connection has been established successfully.');
-  } catch (error) {
-    console.error('Unable to connect to the database:', error);
-    throw error;
+// Suppress SQLite experimental warnings by setting warning filter first
+const originalProcessEmitWarning = process.emitWarning;
+process.emitWarning = function (warning, type, code) {
+  if (type === 'ExperimentalWarning' && warning.includes('SQLite')) {
+    return;
   }
+  return originalProcessEmitWarning.call(this, warning, type, code);
+};
 
-  await createRelationships(sequelize);
+const { DatabaseSync, StatementSync } = require('node:sqlite');
+const { randomUUID } = require('node:crypto');
+const dayjs = require('dayjs');
+const utc = require('dayjs/plugin/utc');
+dayjs.extend(utc);
 
-  return sequelize;
-};
+/**
+ * Database wrapper class that encapsulates db connection and utilities
+ */
+class Database {
+  constructor(dbFilePath) {
+    this.db = new DatabaseSync(dbFilePath);
 
-const createRelationships = async sequelize => {
-  // handling legacy Annotation schema (ann_id removed from navidrome DB schema in this commit: https://github.com/navidrome/navidrome/commit/47378c68828861751b9d1a05d3fc9b29ce8dd9f0)
-  const annotationTableSchema = await sequelize.getQueryInterface().describeTable('annotation');
-
-  // Following Big Fucking Refactor (Navidrome >= 0.55.0), many-to-many relationship exists between Track and Artist via MediaFileArtist table.
-  const hasMediaFileArtists = await sequelize.getQueryInterface().tableExists('media_file_artists');
-
-  const Track = sequelize.define('Track', TrackDefinition.attributes, TrackDefinition.options);
-  const Album = sequelize.define('Album', AlbumDefinition.attributes, AlbumDefinition.options);
-  const Annotation = sequelize.define(
-    'Annotation',
-    AnnotationDefinition.getAttributes(annotationTableSchema),
-    AnnotationDefinition.options
-  );
-  const Artist = sequelize.define('Artist', ArtistDefinition.attributes, ArtistDefinition.options);
-  const User = sequelize.define('User', UserDefinition.attributes, UserDefinition.options);
-
-  Track.belongsTo(Album, { foreignKey: 'album_id' });
-  Track.hasOne(Annotation, { as: 'trackAnnotation', foreignKey: 'item_id' });
-
-  if (!hasMediaFileArtists) {
-    Artist.hasMany(Track, { as: 'tracks', foreignKey: 'artist_id' });
-    Track.belongsTo(Artist, { as: 'artist', foreignKey: 'artist_id' });
-  } else {
-    const MediaFileArtist = sequelize.define(
-      'MediaFileArtist',
-      MediaFileArtistDefinition.attributes,
-      MediaFileArtistDefinition.options
-    );
-
-    Artist.belongsToMany(Track, {
-      through: {
-        model: MediaFileArtist,
-        scope: {
-          role: 'artist'
-        }
-      },
-      foreignKey: 'artist_id',
-      otherKey: 'media_file_id',
-      as: 'tracks'
-    });
+    const result = this.db.prepare('SELECT 1 as test').get();
+    if (result.test !== 1) {
+      throw new Error('Database connection test failed');
+    }
+  }
 
-    Track.belongsToMany(Artist, {
-      through: {
-        model: MediaFileArtist,
-        scope: {
-          role: 'artist'
-        }
-      },
-      foreignKey: 'media_file_id',
-      otherKey: 'artist_id',
-      as: 'artists'
+  /**
+   * Check if a table exists in the database
+   * @param {string} tableName
+   * @returns {boolean}
+   */
+  tableExists(tableName) {
+    const result = this.db
+      .prepare(
+        `
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name=?
+     `
+      )
+      .get(tableName);
+    return !!result;
+  }
+
+  /**
+   * Get table schema information (columns and their properties)
+   * @param {string} tableName
+   * @returns {Object} - Schema information with column names as keys
+   */
+  getTableSchema(tableName) {
+    const columns = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+    const schema = {};
+    columns.forEach(col => {
+      schema[col.name] = {
+        type: col.type,
+        notNull: !!col.notnull,
+        defaultValue: col.dflt_value,
+        primaryKey: !!col.pk
+      };
     });
+    return schema;
   }
 
-  Artist.hasOne(Annotation, { as: 'artistAnnotation', foreignKey: 'item_id' });
+  /**
+   * Check if annotation table has the legacy ann_id column
+   * @returns {boolean} - True if ann_id column exists, false otherwise
+   */
+  hasLegacyAnnotationSchema() {
+    if (!this.tableExists('annotation')) {
+      return false;
+    }
+    const schema = this.getTableSchema('annotation');
+    return 'ann_id' in schema;
+  }
 
-  Album.hasMany(Track, { as: 'tracks', foreignKey: 'album_id' });
-  Album.hasOne(Annotation, { as: 'albumAnnotation', foreignKey: 'item_id' });
+  /**
+   * Check if media_file_artists table exists (new Navidrome schema post BFR >= 0.55.0)
+   * @returns {boolean}
+   */
+  hasMediaFileArtistsTable() {
+    return this.tableExists('media_file_artists');
+  }
+
+  /**
+   * Execute a raw SQL query
+   * @param {string} sql
+   * @param {Array} params
+   * @returns {Array}
+   */
+  query(sql, params = []) {
+    return this.db.prepare(sql).all(...params);
+  }
 
-  Annotation.belongsTo(Track, { as: 'track', foreignKey: 'item_id' });
-  Annotation.belongsTo(Album, { as: 'album', foreignKey: 'item_id' });
-  Annotation.belongsTo(User, { as: 'user', foreignKey: 'user_id' });
+  /**
+   * Prepare a statement for reuse
+   * @param {string} sql
+   * @returns {StatementSync}
+   */
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+
+  close() {
+    this.db.close();
+  }
+
+  /**
+   * Annotation create/update
+   * @param {Object} params - Annotation parameters
+   * @param {('media_file' | 'album' | 'artist')} params.itemType
+   * @param {string} params.userId
+   * @param {string} params.itemId
+   * @param {Object} params.update - Update object with new values
+   * @param {boolean} params.needsCreate - Whether to create new annotation
+   * @returns {Promise<void>}
+   */
+  async upsertAnnotation({ itemType, userId, itemId, update, needsCreate }) {
+    if (update.play_date) {
+      const playDate = dayjs.isDayjs(update.play_date) ? update.play_date : dayjs.utc(update.play_date);
+      update.play_date = playDate.format('YYYY-MM-DD HH:mm:ss');
+    }
+    if (update.starred_at) {
+      // If already a dayjs object (from CSV), use as-is; if string, treat as UTC
+      const starredAt = dayjs.isDayjs(update.starred_at) ? update.starred_at : dayjs.utc(update.starred_at);
+      update.starred_at = starredAt.format('YYYY-MM-DD HH:mm:ss');
+    }
+
+    if (needsCreate) {
+      const record = {
+        item_type: itemType,
+        user_id: userId,
+        item_id: itemId,
+        play_count: 0,
+        starred: 0,
+        rating: 0,
+        play_date: null,
+        starred_at: null,
+        ...update
+      };
+
+      if (this.hasLegacyAnnotationSchema()) {
+        record.ann_id = randomUUID();
+      }
+
+      const columns = Object.keys(record).join(', ');
+      const placeholders = Object.keys(record)
+        .map(() => '?')
+        .join(', ');
+
+      this.prepare(`INSERT INTO annotation (${columns}) VALUES (${placeholders})`).run(...Object.values(record));
+    } else {
+      const setClauses = Object.keys(update)
+        .map(key => `${key} = ?`)
+        .join(', ');
+
+      this.prepare(
+        `
+        UPDATE annotation 
+        SET ${setClauses}
+        WHERE item_type = ? 
+        AND user_id = ? 
+        AND item_id = ?
+      `
+      ).run(...Object.values(update), itemType, userId, itemId);
+    }
+  }
+}
+
+exports.init = async dbFilePath => {
+  try {
+    const database = new Database(dbFilePath);
+    console.log('Connection has been established successfully.');
+    return database;
+  } catch (error) {
+    console.error('Unable to connect to the database:', error);
+    throw error;
+  }
 };

lib/handlers/dbManager.js

@@ -1,3 +1,7 @@
+const dayjs = require('dayjs');
+const utc = require('dayjs/plugin/utc');
+dayjs.extend(utc);
+
 /**
  * Normalize path to use forward slashes
  * @param {string} path
@@ -25,7 +29,7 @@ const findBestMatch = (mbTrack, ndTracks) => {
   let bestMatchScore = 0;
 
   ndTracks.filter(Boolean).forEach(ndTrack => {
-    const ndTrackSegments = getSegments(ndTrack.toJSON().path).reverse();
+    const ndTrackSegments = getSegments(ndTrack.path).reverse();
     let matchScore = 0;
 
     if (mbTrackSegments[0] !== ndTrackSegments[0]) {
@@ -47,4 +51,24 @@ const findBestMatch = (mbTrack, ndTracks) => {
   return bestMatch;
 };
 
-module.exports = { findBestMatch };
+/**
+ * Safe date comparison - handles dayjs objects vs database strings
+ * All comparisons are done in UTC to ensure consistency
+ * @param {dayjs|string|null} dateA - Usually from CSV (dayjs UTC object)
+ * @param {string|null} dateB - Usually from database (string)
+ * @returns {boolean}
+ */
+const isDateAfter = (dateA, dateB) => {
+  if (!dateA) return false;
+  if (!dateB) return true;
+
+  // dateA: If dayjs object (from CSV), use as is; if string, treat as UTC
+  const dayjsA = dayjs.isDayjs(dateA) ? dateA : dayjs.utc(dateA);
+  
+  // dateB: Database strings are already in UTC format, treat them as such
+  const dayjsB = dayjs.utc(dateB);
+
+  return dayjsA.isAfter(dayjsB);
+};
+
+module.exports = { findBestMatch, isDateAfter };