@ozdao/martyrs 0.2.477 → 0.2.479

package/src/modules/music/components/pages/MusicLibrary.vue

@@ -65,7 +65,8 @@
     
     <!-- Artists Tab -->
     <div v-else-if="activeTab === 'artists'" class="artists-tab">
-      <div class="flex-between flex mn-b-small">
+      <ArtistManager/>
+      <!-- <div class="flex-between flex mn-b-small">
         <h2 class="t-white">Your Artists</h2>
       </div>
       
@@ -74,7 +75,7 @@
         <p class="t-grey t-medium">Create your first artist profile to see it here</p>
       </div>
       
-      <ArtistList v-else :artists="userArtists" />
+      <ArtistList v-else :artists="userArtists" /> -->
     </div>
     
     <!-- Tracks Tab -->
@@ -124,6 +125,7 @@ import TrackList from '../lists/TrackList.vue';
 import AlbumList from '../lists/AlbumList.vue';
 import PlaylistList from '../lists/PlaylistList.vue';
 import ArtistList from '../lists/ArtistList.vue';
+import ArtistManager from '../pages/ArtistManager.vue';
 import Button from '@martyrs/src/components/Button/Button.vue';
 import Loader from '@martyrs/src/components/Loader/Loader.vue';
 import Popup from '@martyrs/src/components/Popup/Popup.vue';
@@ -168,12 +170,7 @@ const fetchLibraryData = async () => {
     }
     
     // Fetch user's content
-    await Promise.all([
-      // playlistsActions.fetchUserPlaylists().then(playlists => userPlaylists.value = playlists || []),
-      // albumsActions.fetchUserAlbums(authState.user._id).then(albums => userAlbums.value = albums || []),
-      // artistsActions.fetchUserArtists(authState.user._id).then(artists => userArtists.value = artists || []),
-      tracksActions.fetchUserTracks(authState.user._id).then(tracks => userTracks.value = tracks || [])
-    ]);
+    await tracksActions.fetchUserTracks(authState.user._id).then(tracks => userTracks.value = tracks || []);
   } catch (error) {
     console.error('Error fetching library data:', error);
   } finally {

package/src/modules/music/controllers/album.controller.js

@@ -1,57 +1,45 @@
-// controllers/album.controller.js
-const globalsQuery = require('@martyrs/src/modules/globals/controllers/utils/queryProcessor');
-
-module.exports = function(app,db) {
-  const { MusicController } = require('./music.controller')(app,db);
-  
+import music from './music.controller.js';
+export default (function (app, db) {
+  const { MusicController } = music(app, db);
   class AlbumController extends MusicController {
     constructor(app) {
       super('/api/albums', app, db, db.album);
     }
-    
     // Get tracks for a specific album
     async getAlbumTracks(req, res) {
       try {
         const albumId = req.params.albumId;
-        
         // Check if album exists and user has access
         const album = await db.album.findById(albumId);
         if (!album) {
           return res.status(404).json({ error: 'Album not found' });
         }
-        
         // Check access using ABAC
         const accessResult = await this.abac.checkAccess({
           user: req.userId,
           resource: 'albums',
           action: 'read',
-          currentResource: album
+          currentResource: album,
         });
-        
         if (!accessResult.allowed && !album.isPublic) {
-          return res.status(403).json({ 
+          return res.status(403).json({
             errorCode: accessResult.reason,
-            message: 'Access Denied'
+            message: 'Access Denied',
           });
         }
-        
         // Find tracks for this album
-        const tracks = await db.track.find({ album: albumId, status: 'published' })
-          .sort({ releaseDate: -1 });
-        
+        const tracks = await db.track.find({ album: albumId, status: 'published' }).sort({ releaseDate: -1 });
         res.json(tracks);
       } catch (error) {
         this.logger.error(`Error getting album tracks: ${error.message}`);
         res.status(500).json({ error: error.message });
       }
     }
-    
     // Get featured albums
     async getFeaturedAlbums(req, res) {
       try {
         const cacheKey = 'featured-albums';
         let featuredAlbums = await this.cache.get(cacheKey);
-        
         if (!featuredAlbums) {
           // Get featured albums with track counts
           featuredAlbums = await db.album.aggregate([
@@ -61,22 +49,20 @@ module.exports = function(app,db) {
                 from: 'tracks',
                 localField: '_id',
                 foreignField: 'album',
-                as: 'tracks'
-              }
+                as: 'tracks',
+              },
             },
             {
               $addFields: {
-                trackCount: { $size: '$tracks' }
-              }
+                trackCount: { $size: '$tracks' },
+              },
             },
             { $project: { tracks: 0 } },
             { $sort: { releaseDate: -1 } },
-            { $limit: 10 }
+            { $limit: 10 },
           ]);
-          
           await this.cache.set(cacheKey, featuredAlbums, 3600); // Cache for 1 hour
         }
-        
         res.json(featuredAlbums);
       } catch (error) {
         this.logger.error(`Error getting featured albums: ${error.message}`);
@@ -84,15 +70,13 @@ module.exports = function(app,db) {
       }
     }
   }
-  
-  const albumController = new AlbumController(app,db); // Pass app in actual implementation
-  
+  const albumController = new AlbumController(app, db); // Pass app in actual implementation
   return {
     create: albumController.create.bind(albumController),
     read: albumController.read.bind(albumController),
     update: albumController.update.bind(albumController),
     delete: albumController.delete.bind(albumController),
     getAlbumTracks: albumController.getAlbumTracks.bind(albumController),
-    getFeaturedAlbums: albumController.getFeaturedAlbums.bind(albumController)
+    getFeaturedAlbums: albumController.getFeaturedAlbums.bind(albumController),
   };
-};
+});

package/src/modules/music/controllers/artist.controller.js

@@ -1,94 +1,84 @@
-// controllers/artist.controller.js (continued)
-module.exports = function(app,db) {
-  const { MusicController } = require('./music.controller')(app,db);
-  
+import music from './music.controller.js';
+export default (function (app, db) {
+  const { MusicController } = music(app, db);
   class ArtistController extends MusicController {
     constructor(app) {
       super('/api/artists', app, db, db.artist);
     }
-    
     // Get artist discography
     async getDiscography(req, res) {
       try {
         const artistId = req.params.artistId;
-        
         // Verify artist exists
         const artist = await db.artist.findById(artistId);
         if (!artist) {
           return res.status(404).json({ error: 'Artist not found' });
         }
-        
         // Get all albums by this artist
-        const albums = await db.album.find({
-          artist: artistId,
-          status: 'published',
-          isPublic: true
-        }).sort({ releaseDate: -1 });
-        
+        const albums = await db.album
+          .find({
+            artist: artistId,
+            status: 'published',
+            isPublic: true,
+          })
+          .sort({ releaseDate: -1 });
         // Get all tracks not in albums
-        const singleTracks = await db.track.find({
-          artist: artistId,
-          album: { $exists: false },
-          status: 'published',
-          isPublic: true
-        }).sort({ releaseDate: -1 });
-        
+        const singleTracks = await db.track
+          .find({
+            artist: artistId,
+            album: { $exists: false },
+            status: 'published',
+            isPublic: true,
+          })
+          .sort({ releaseDate: -1 });
         res.json({
           artist,
           albums,
-          singles: singleTracks
+          singles: singleTracks,
         });
       } catch (error) {
         this.logger.error(`Error getting artist discography: ${error.message}`);
         res.status(500).json({ error: error.message });
       }
     }
-    
     // Verify an artist (admin only)
     async verifyArtist(req, res) {
       try {
         const artistId = req.params.artistId;
-        
         // Check if user is admin
         if (!req.userRoles.includes('ROLE_ADMIN')) {
           return res.status(403).json({ error: 'Only administrators can verify artists' });
         }
-        
         const artist = await db.artist.findById(artistId);
         if (!artist) {
           return res.status(404).json({ error: 'Artist not found' });
         }
-        
         artist.isVerified = true;
         await artist.save();
-        
         await this.cache.flush();
-        
         res.json({ success: true, artist });
       } catch (error) {
         this.logger.error(`Error verifying artist: ${error.message}`);
         res.status(500).json({ error: error.message });
       }
     }
-    
     // Get related artists
     async getRelatedArtists(req, res) {
       try {
         const artistId = req.params.artistId;
-        
         // Find genres of this artist
         const artist = await db.artist.findById(artistId);
         if (!artist) {
           return res.status(404).json({ error: 'Artist not found' });
         }
-        
         // Get artists with similar genres
-        const relatedArtists = await db.artist.find({
-          _id: { $ne: artistId },
-          genre: { $in: artist.genre },
-          status: 'published'
-        }).limit(5);
-        
+        const relatedArtists = await db.artist
+          .find({
+            _id: { $ne: artistId },
+            genre: { $in: artist.genre },
+            status: 'published',
+          })
+          .limit(5);
         res.json(relatedArtists);
       } catch (error) {
         this.logger.error(`Error getting related artists: ${error.message}`);
@@ -96,9 +86,7 @@ module.exports = function(app,db) {
       }
     }
   }
-  
-  const artistController = new ArtistController(app,db);
-  
+  const artistController = new ArtistController(app, db);
   return {
     create: artistController.create.bind(artistController),
     read: artistController.read.bind(artistController),
@@ -106,6 +94,6 @@ module.exports = function(app,db) {
     delete: artistController.delete.bind(artistController),
     getDiscography: artistController.getDiscography.bind(artistController),
     verifyArtist: artistController.verifyArtist.bind(artistController),
-    getRelatedArtists: artistController.getRelatedArtists.bind(artistController)
+    getRelatedArtists: artistController.getRelatedArtists.bind(artistController),
   };
-};
+});

package/src/modules/music/controllers/genre.controller.js

@@ -1,55 +1,49 @@
-// controllers/genre.controller.js
-module.exports = function(app,db) {
-  const { MusicController } = require('./music.controller')(app,db);
-  
+import music from './music.controller.js';
+export default (function (app, db) {
+  const { MusicController } = music(app, db);
   class GenreController extends MusicController {
     constructor(app) {
       super('/api/genres', app, db, db.genre);
     }
-    
     // Get tracks by genre
     async getGenreTracks(req, res) {
       try {
         const genreId = req.params.genreId;
-        
         // Verify genre exists
         const genre = await db.genre.findById(genreId);
         if (!genre) {
           return res.status(404).json({ error: 'Genre not found' });
         }
-        
         // Get tracks from this genre
-        const tracks = await db.track.find({
-          genre: genreId,
-          status: 'published',
-          isPublic: true
-        })
-        .sort({ releaseDate: -1 })
-        .limit(50)
-        .populate('artist', 'name')
-        .populate('album', 'title coverUrl');
-        
+        const tracks = await db.track
+          .find({
+            genre: genreId,
+            status: 'published',
+            isPublic: true,
+          })
+          .sort({ releaseDate: -1 })
+          .limit(50)
+          .populate('artist', 'name')
+          .populate('album', 'title coverUrl');
         res.json({
           genre,
-          tracks
+          tracks,
         });
       } catch (error) {
         this.logger.error(`Error getting genre tracks: ${error.message}`);
         res.status(500).json({ error: error.message });
       }
     }
-    
     // Get popular genres
     async getPopularGenres(req, res) {
       try {
         const limit = parseInt(req.query.limit) || 10;
-        
-        const genres = await db.genre.find({
-          status: 'published'
-        })
-        .sort({ popularity: -1 })
-        .limit(limit);
-        
+        const genres = await db.genre
+          .find({
+            status: 'published',
+          })
+          .sort({ popularity: -1 })
+          .limit(limit);
         res.json(genres);
       } catch (error) {
         this.logger.error(`Error getting popular genres: ${error.message}`);
@@ -57,15 +51,13 @@ module.exports = function(app,db) {
       }
     }
   }
-  
-  const genreController = new GenreController(app,db);
-  
+  const genreController = new GenreController(app, db);
   return {
     create: genreController.create.bind(genreController),
     read: genreController.read.bind(genreController),
     update: genreController.update.bind(genreController),
     delete: genreController.delete.bind(genreController),
     getGenreTracks: genreController.getGenreTracks.bind(genreController),
-    getPopularGenres: genreController.getPopularGenres.bind(genreController)
+    getPopularGenres: genreController.getPopularGenres.bind(genreController),
   };
-};
+});

package/src/modules/music/controllers/music.controller.js

@@ -1,86 +1,71 @@
-// controllers/music.controller.js
-const CRUD = require('@martyrs/src/modules/globals/controllers/classes/globals.crud');
-const Logger = require('@martyrs/src/modules/globals/controllers/classes/globals.logger');
-const Cache = require('@martyrs/src/modules/globals/controllers/classes/globals.cache');
-const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js');
-
-module.exports = function(app, db) {
+import globalsabac from '@martyrs/src/modules/globals/controllers/classes/globals.abac.js';
+import Cache from '@martyrs/src/modules/globals/controllers/classes/globals.cache.js';
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/globals.crud.js';
+import Logger from '@martyrs/src/modules/globals/controllers/classes/globals.logger.js';
+const { getInstance } = globalsabac;
+export default (function (app, db) {
   const logger = new Logger(db);
   const cache = new Cache();
   const abac = getInstance(db);
-  
   class MusicController extends CRUD {
     constructor(basePath, app, db, model, options) {
       super(basePath, app, db, model, options);
       this.logger = logger;
       this.cache = cache;
       this.abac = abac;
-      
       // Log initialization to help debugging
-      console.log(`[MusicController] Initialized with basePath: ${basePath}`);
-      console.log(`[MusicController] Model: ${model?.modelName || 'No model provided'}`);
+      // console.log(`[MusicController] Initialized with basePath: ${basePath}`);
+      // console.log(`[MusicController] Model: ${model?.modelName || 'No model provided'}`);
     }
-    
     // Override the create method to handle ownership
     async create(req, res) {
       try {
         console.log(`[MusicController] Create request received:`, {
           userId: req.userId,
-          body: req.body
+          body: req.body,
         });
-        
         // Ensure userId exists
         if (!req.userId) {
           console.error('[MusicController] No userId found in request, auth middleware may have failed');
-          return res.status(401).json({ 
+          return res.status(401).json({
             errorCode: 'AUTHENTICATION_REQUIRED',
-            message: 'You must be authenticated to perform this action'
+            message: 'You must be authenticated to perform this action',
           });
         }
-        
         // Set creator and owner if not provided
         if (!req.body.creator) {
           req.body.creator = {
             type: 'user', // Note lowercase - must match your schema expectations
-            target: req.userId
+            target: req.userId,
           };
         }
-        
         if (!req.body.owner) {
           req.body.owner = {
             type: 'user', // Note lowercase - must match your schema expectations
-            target: req.userId
+            target: req.userId,
           };
         }
-        
         console.log(`[MusicController] Checking access with ABAC`);
-        
         // Check access using ABAC
         const accessResult = await this.abac.checkAccess({
           user: req.userId,
           resource: this.model.collection.collectionName,
           action: 'create',
-          data: req.body
+          data: req.body,
         });
-        
         console.log(`[MusicController] Access check result:`, accessResult);
-        
         if (!accessResult.allowed) {
           console.error(`[MusicController] Access denied:`, accessResult.reason);
-          return res.status(403).json({ 
+          return res.status(403).json({
             errorCode: accessResult.reason,
-            message: 'Access Denied'
+            message: 'Access Denied',
           });
         }
-        
         console.log(`[MusicController] Creating record with data:`, req.body);
-        
         // Continue with the creation
         const createdData = await this.model.create(req.body);
         await this.cache.flush();
-        
         console.log(`[MusicController] Record created successfully:`, createdData._id);
-        
         res.status(201).json(createdData);
       } catch (error) {
         console.error(`[MusicController] Error creating record:`, error);
@@ -88,41 +73,33 @@ module.exports = function(app, db) {
         res.status(500).json({ error: error.message });
       }
     }
-
-    
     // Override the update method to check ownership
     async update(req, res) {
       try {
         const resourceId = req.body._id;
         const resource = await this.model.findById(resourceId);
-        
         if (!resource) {
           return res.status(404).json({ error: 'Resource not found' });
         }
-        
         // Check access using ABAC
         const accessResult = await this.abac.checkAccess({
           user: req.userId,
           resource: this.model.collection.collectionName,
           action: 'update',
           data: req.body,
-          currentResource: resource
+          currentResource: resource,
         });
-        
         if (!accessResult.allowed) {
-          return res.status(403).json({ 
+          return res.status(403).json({
             errorCode: accessResult.reason,
-            message: 'Access Denied'
+            message: 'Access Denied',
           });
         }
-        
         // Continue with the update
-        const updatedData = await this.model.findOneAndUpdate(
-          { _id: resourceId },
-          req.body,
-          { new: true, runValidators: true }
-        );
-        
+        const updatedData = await this.model.findOneAndUpdate({ _id: resourceId }, req.body, {
+          new: true,
+          runValidators: true,
+        });
         await this.cache.flush();
         res.json(updatedData);
       } catch (error) {
@@ -130,33 +107,28 @@ module.exports = function(app, db) {
         res.status(500).json({ error: error.message });
       }
     }
-    
     // Override the delete method to check ownership
     async delete(req, res) {
       try {
         const resourceId = req.body._id;
         const resource = await this.model.findById(resourceId);
-        
         if (!resource) {
           return res.status(404).json({ error: 'Resource not found' });
         }
-        
         // Check access using ABAC
         const accessResult = await this.abac.checkAccess({
           user: req.userId,
           resource: this.model.collection.collectionName,
           action: 'delete',
           data: req.body,
-          currentResource: resource
+          currentResource: resource,
         });
-        
         if (!accessResult.allowed) {
-          return res.status(403).json({ 
+          return res.status(403).json({
             errorCode: accessResult.reason,
-            message: 'Access Denied'
+            message: 'Access Denied',
           });
         }
-        
         // Continue with the deletion
         await this.model.findOneAndDelete({ _id: resourceId });
         await this.cache.flush();
@@ -167,8 +139,7 @@ module.exports = function(app, db) {
       }
     }
   }
-  
   return {
-    MusicController
+    MusicController,
   };
-};
+});