@ozdao/martyrs 0.2.485 → 0.2.487

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

@@ -1,145 +0,0 @@
-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'}`);
-    }
-    // Override the create method to handle ownership
-    async create(req, res) {
-      try {
-        console.log(`[MusicController] Create request received:`, {
-          userId: req.userId,
-          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({
-            errorCode: 'AUTHENTICATION_REQUIRED',
-            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,
-          };
-        }
-        if (!req.body.owner) {
-          req.body.owner = {
-            type: 'user', // Note lowercase - must match your schema expectations
-            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,
-        });
-        console.log(`[MusicController] Access check result:`, accessResult);
-        if (!accessResult.allowed) {
-          console.error(`[MusicController] Access denied:`, accessResult.reason);
-          return res.status(403).json({
-            errorCode: accessResult.reason,
-            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);
-        this.logger.error(`Error creating ${this.model.collection.collectionName}: ${error.message}`);
-        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,
-        });
-        if (!accessResult.allowed) {
-          return res.status(403).json({
-            errorCode: accessResult.reason,
-            message: 'Access Denied',
-          });
-        }
-        // Continue with the update
-        const updatedData = await this.model.findOneAndUpdate({ _id: resourceId }, req.body, {
-          new: true,
-          runValidators: true,
-        });
-        await this.cache.flush();
-        res.json(updatedData);
-      } catch (error) {
-        this.logger.error(`Error updating ${this.model.collection.collectionName}: ${error.message}`);
-        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,
-        });
-        if (!accessResult.allowed) {
-          return res.status(403).json({
-            errorCode: accessResult.reason,
-            message: 'Access Denied',
-          });
-        }
-        // Continue with the deletion
-        await this.model.findOneAndDelete({ _id: resourceId });
-        await this.cache.flush();
-        res.status(204).send();
-      } catch (error) {
-        this.logger.error(`Error deleting ${this.model.collection.collectionName}: ${error.message}`);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  }
-  return {
-    MusicController,
-  };
-});

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

@@ -1,146 +0,0 @@
-import music from './music.controller.js';
-export default (function (app, db) {
-  const { MusicController } = music(app, db);
-  class PlaylistController extends MusicController {
-    constructor(app, db) {
-      super('/api/playlists', app, db, db.playlist);
-    }
-    // Add track to playlist
-    async addTrack(req, res) {
-      try {
-        const { playlistId, trackId } = req.params;
-        // Find the playlist
-        const playlist = await db.playlist.findById(playlistId);
-        if (!playlist) {
-          return res.status(404).json({ error: 'Playlist not found' });
-        }
-        // Check access using ABAC
-        const accessResult = await this.abac.checkAccess({
-          user: req.userId,
-          resource: 'playlists',
-          action: 'update',
-          currentResource: playlist,
-        });
-        if (!accessResult.allowed) {
-          return res.status(403).json({
-            errorCode: accessResult.reason,
-            message: 'Access Denied',
-          });
-        }
-        // Check if track exists
-        const track = await db.track.findById(trackId);
-        if (!track) {
-          return res.status(404).json({ error: 'Track not found' });
-        }
-        // Check if track is already in playlist
-        const trackExists = playlist.tracks.some(item => item.track.toString() === trackId);
-        if (trackExists) {
-          return res.status(400).json({ error: 'Track already in playlist' });
-        }
-        // Add track to playlist
-        playlist.tracks.push({
-          track: trackId,
-          addedAt: new Date(),
-        });
-        await playlist.save();
-        await this.cache.flush();
-        res.json(playlist);
-      } catch (error) {
-        this.logger.error(`Error adding track to playlist: ${error.message}`);
-        res.status(500).json({ error: error.message });
-      }
-    }
-    // Remove track from playlist
-    async removeTrack(req, res) {
-      try {
-        const { playlistId, trackId } = req.params;
-        // Find the playlist
-        const playlist = await db.playlist.findById(playlistId);
-        if (!playlist) {
-          return res.status(404).json({ error: 'Playlist not found' });
-        }
-        // Check access using ABAC
-        const accessResult = await this.abac.checkAccess({
-          user: req.userId,
-          resource: 'playlists',
-          action: 'update',
-          currentResource: playlist,
-        });
-        if (!accessResult.allowed) {
-          return res.status(403).json({
-            errorCode: accessResult.reason,
-            message: 'Access Denied',
-          });
-        }
-        // Remove track from playlist
-        playlist.tracks = playlist.tracks.filter(item => item.track.toString() !== trackId);
-        await playlist.save();
-        await this.cache.flush();
-        res.json(playlist);
-      } catch (error) {
-        this.logger.error(`Error removing track from playlist: ${error.message}`);
-        res.status(500).json({ error: error.message });
-      }
-    }
-    // Get user playlists
-    async getUserPlaylists(req, res) {
-      try {
-        const userId = req.params.userId || req.userId;
-        // Get playlists where user is owner or collaborator
-        const playlists = await db.playlist
-          .find({
-            $or: [{ 'owner.target': userId, 'owner.type': 'User' }, { collaborators: userId }],
-          })
-          .sort({ updatedAt: -1 });
-        res.json(playlists);
-      } catch (error) {
-        this.logger.error(`Error getting user playlists: ${error.message}`);
-        res.status(500).json({ error: error.message });
-      }
-    }
-    // Add collaborator to playlist
-    async addCollaborator(req, res) {
-      try {
-        const { playlistId, userId } = req.params;
-        // Find the playlist
-        const playlist = await db.playlist.findById(playlistId);
-        if (!playlist) {
-          return res.status(404).json({ error: 'Playlist not found' });
-        }
-        // Only owner can add collaborators
-        if (playlist.owner.target.toString() !== req.userId) {
-          return res.status(403).json({ error: 'Only playlist owner can add collaborators' });
-        }
-        // Check if user exists
-        const user = await db.mongoose.model('User').findById(userId);
-        if (!user) {
-          return res.status(404).json({ error: 'User not found' });
-        }
-        // Check if user is already a collaborator
-        if (playlist.collaborators.includes(userId)) {
-          return res.status(400).json({ error: 'User is already a collaborator' });
-        }
-        // Add collaborator
-        playlist.collaborators.push(userId);
-        playlist.isCollaborative = true;
-        await playlist.save();
-        await this.cache.flush();
-        res.json(playlist);
-      } catch (error) {
-        this.logger.error(`Error adding collaborator to playlist: ${error.message}`);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  }
-  const playlistController = new PlaylistController(app, db);
-  return {
-    create: playlistController.create.bind(playlistController),
-    read: playlistController.read.bind(playlistController),
-    update: playlistController.update.bind(playlistController),
-    delete: playlistController.delete.bind(playlistController),
-    addTrack: playlistController.addTrack.bind(playlistController),
-    removeTrack: playlistController.removeTrack.bind(playlistController),
-    getUserPlaylists: playlistController.getUserPlaylists.bind(playlistController),
-    addCollaborator: playlistController.addCollaborator.bind(playlistController),
-  };
-});

package/src/modules/music/routes/album.routes.js

@@ -1,28 +0,0 @@
-import middlewareFactoryAuth from '@martyrs/src/modules/auth/controllers/middlewares/index.js';
-import album from '../controllers/album.controller.js';
-export default (function (app, db, origins, publicPath) {
-  const controller = album(app, db);
-  const { authJwt } = middlewareFactoryAuth(db);
-  // CRUD operations for albums
-  app.post('/api/albums/create', [authJwt.verifyToken], controller.create);
-  app.get('/api/albums/read', controller.read);
-  app.put('/api/albums/update', [authJwt.verifyToken], controller.update);
-  app.delete('/api/albums/delete', [authJwt.verifyToken], controller.delete);
-  // Get album tracks
-  app.get('/api/albums/:albumId/tracks', controller.getAlbumTracks);
-  // Get featured albums
-  app.get('/api/albums/featured', controller.getFeaturedAlbums);
-  // Get album by URL
-  app.get('/api/albums/url/:url', async (req, res) => {
-    try {
-      const album = await db.album.findOne({ url: req.params.url }).populate('artist');
-      if (!album) {
-        return res.status(404).json({ error: 'Album not found' });
-      }
-      res.json(album);
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ error: error.message });
-    }
-  });
-});

package/src/modules/music/routes/artist.routes.js

@@ -1,30 +0,0 @@
-import middlewareFactoryAuth from '@martyrs/src/modules/auth/controllers/middlewares/index.js';
-import artist from '../controllers/artist.controller.js';
-export default (function (app, db, origins, publicPath) {
-  const controller = artist(app, db);
-  const { authJwt } = middlewareFactoryAuth(db);
-  // CRUD operations for artists
-  app.post('/api/artists/create', [authJwt.verifyToken], controller.create);
-  app.get('/api/artists/read', controller.read);
-  app.put('/api/artists/update', [authJwt.verifyToken], controller.update);
-  app.delete('/api/artists/delete', [authJwt.verifyToken], controller.delete);
-  // Get artist discography
-  app.get('/api/artists/:artistId/discography', controller.getDiscography);
-  // Verify artist (admin only)
-  app.put('/api/artists/:artistId/verify', [authJwt.verifyToken, authJwt.isAdmin], controller.verifyArtist);
-  // Get related artists
-  app.get('/api/artists/:artistId/related', controller.getRelatedArtists);
-  // Get artist by URL
-  app.get('/api/artists/url/:url', async (req, res) => {
-    try {
-      const artist = await db.artist.findOne({ url: req.params.url });
-      if (!artist) {
-        return res.status(404).json({ error: 'Artist not found' });
-      }
-      res.json(artist);
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ error: error.message });
-    }
-  });
-});

package/src/modules/music/routes/genre.routes.js

@@ -1,28 +0,0 @@
-import middlewareFactoryAuth from '@martyrs/src/modules/auth/controllers/middlewares/index.js';
-import genre from '../controllers/genre.controller.js';
-export default (function (app, db, origins, publicPath) {
-  const controller = genre(app, db);
-  const { authJwt } = middlewareFactoryAuth(db);
-  // CRUD operations for genres
-  app.post('/api/genres/create', [authJwt.verifyToken, authJwt.isAdmin], controller.create);
-  app.get('/api/genres/read', controller.read);
-  app.put('/api/genres/update', [authJwt.verifyToken, authJwt.isAdmin], controller.update);
-  app.delete('/api/genres/delete', [authJwt.verifyToken, authJwt.isAdmin], controller.delete);
-  // Get tracks by genre
-  app.get('/api/genres/:genreId/tracks', controller.getGenreTracks);
-  // Get popular genres
-  app.get('/api/genres/popular', controller.getPopularGenres);
-  // Get genre by URL
-  app.get('/api/genres/url/:url', async (req, res) => {
-    try {
-      const genre = await db.genre.findOne({ url: req.params.url });
-      if (!genre) {
-        return res.status(404).json({ error: 'Genre not found' });
-      }
-      res.json(genre);
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ error: error.message });
-    }
-  });
-});

package/src/modules/music/routes/music.routes.js

@@ -1,106 +0,0 @@
-import middlewareFactoryAuth from '@martyrs/src/modules/auth/controllers/middlewares/index.js';
-import globalsabac from '@martyrs/src/modules/globals/controllers/classes/globals.abac.js';
-import controllerFactory from '../controllers/music.controller.js';
-// ABAC
-const { getInstance } = globalsabac;
-export default (function (app, db, origins, publicPath) {
-  const { MusicController } = controllerFactory(app, db);
-  const { authJwt } = middlewareFactoryAuth(db);
-  const controller = new MusicController('/api/tracks', app, db, db.track, {
-    disableDefaultRoutes: true,
-  });
-  const abac = getInstance(db);
-  // CRUD operations for tracks
-  app.post(
-    '/api/tracks/create',
-    [
-      authJwt.verifyToken(), // Auth middleware
-      (req, res, next) => {
-        // Debugging middleware
-        console.log('[Route] /api/tracks/create - Request received');
-        console.log('[Route] User ID from token:', req.userId);
-        next();
-      },
-    ],
-    controller.create.bind(controller) // Bind to ensure 'this' context
-  );
-  app.get('/api/tracks/read', controller.read.bind(controller));
-  app.put('/api/tracks/update', [authJwt.verifyToken], controller.update.bind(controller));
-  app.delete('/api/tracks/delete', [authJwt.verifyToken], controller.delete.bind(controller));
-  // Get track by URL
-  app.get('/api/tracks/url/:url', async (req, res) => {
-    try {
-      const track = await db.track.findOne({ url: req.params.url });
-      if (!track) {
-        return res.status(404).json({ error: 'Track not found' });
-      }
-      // Check access using ABAC
-      const accessResult = await abac.checkAccess({
-        user: req.userId,
-        resource: 'tracks',
-        action: 'read',
-        currentResource: track,
-      });
-      if (!accessResult.allowed && !track.isPublic) {
-        return res.status(403).json({
-          errorCode: accessResult.reason,
-          message: 'Access Denied',
-        });
-      }
-      res.json(track);
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ error: error.message });
-    }
-  });
-  // Get recent tracks
-  app.get('/api/tracks/recent', async (req, res) => {
-    try {
-      const limit = parseInt(req.query.limit) || 10;
-      const recentTracks = await db.track
-        .find({
-          status: 'published',
-          isPublic: true,
-        })
-        .sort({ createdAt: -1 })
-        .limit(limit);
-      res.json(recentTracks);
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ error: error.message });
-    }
-  });
-  // Get popular tracks
-  app.get('/api/tracks/popular', async (req, res) => {
-    try {
-      const limit = parseInt(req.query.limit) || 10;
-      const popularTracks = await db.track
-        .find({
-          status: 'published',
-          isPublic: true,
-        })
-        .sort({ playCount: -1 })
-        .limit(limit);
-      res.json(popularTracks);
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ error: error.message });
-    }
-  });
-  // Get tracks by genre
-  app.get('/api/tracks/genre/:genreId', async (req, res) => {
-    try {
-      const tracks = await db.track
-        .find({
-          genre: req.params.genreId,
-          status: 'published',
-          isPublic: true,
-        })
-        .sort({ releaseDate: -1 });
-      res.json(tracks);
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ error: error.message });
-    }
-  });
-});

package/src/modules/music/routes/playlist.routes.js

@@ -1,47 +0,0 @@
-import middlewareFactoryAuth from '@martyrs/src/modules/auth/controllers/middlewares/index.js';
-import playlist from '../controllers/playlist.controller.js';
-export default (function (app, db, origins, publicPath) {
-  const controller = playlist(app, db);
-  const { authJwt } = middlewareFactoryAuth(db);
-  // CRUD operations for playlists
-  app.post('/api/playlists/create', [authJwt.verifyToken], controller.create);
-  app.get('/api/playlists/read', controller.read);
-  app.put('/api/playlists/update', [authJwt.verifyToken], controller.update);
-  app.delete('/api/playlists/delete', [authJwt.verifyToken], controller.delete);
-  // Get user playlists
-  app.get('/api/playlists/user/:userId?', [authJwt.verifyToken], controller.getUserPlaylists);
-  // Add track to playlist
-  app.post('/api/playlists/:playlistId/tracks/:trackId', [authJwt.verifyToken], controller.addTrack);
-  // Remove track from playlist
-  app.delete('/api/playlists/:playlistId/tracks/:trackId', [authJwt.verifyToken], controller.removeTrack);
-  // Add collaborator to playlist
-  app.post('/api/playlists/:playlistId/collaborators/:userId', [authJwt.verifyToken], controller.addCollaborator);
-  // Get playlist by URL
-  app.get('/api/playlists/url/:url', async (req, res) => {
-    try {
-      const playlist = await db.playlist.findOne({ url: req.params.url }).populate({
-        path: 'tracks.track',
-        select: '-lyrics',
-      });
-      if (!playlist) {
-        return res.status(404).json({ error: 'Playlist not found' });
-      }
-      // If not public, check permissions
-      if (!playlist.isPublic) {
-        // Only owner and collaborators can see private playlists
-        if (!req.userId) {
-          return res.status(403).json({ error: 'Access denied to private playlist' });
-        }
-        const isOwner = playlist.owner.target.toString() === req.userId;
-        const isCollaborator = playlist.collaborators.some(collab => collab.toString() === req.userId);
-        if (!isOwner && !isCollaborator) {
-          return res.status(403).json({ error: 'Access denied to private playlist' });
-        }
-      }
-      res.json(playlist);
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ error: error.message });
-    }
-  });
-});