@ozdao/martyrs 0.2.470 → 0.2.472

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

@@ -0,0 +1,174 @@
+// 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) {
+  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

@@ -0,0 +1,182 @@
+// controllers/playlist.controller.js
+module.exports = function(app,db) {
+   const { MusicController } = require('./music.controller')(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/controllers/search.controller.js

@@ -0,0 +1,103 @@
+// controllers/search.controller.js
+module.exports = function(app,db) {
+  const Logger = require('@martyrs/src/modules/globals/controllers/classes/globals.logger');
+  const Cache = require('@martyrs/src/modules/globals/controllers/classes/globals.cache');
+  
+  const logger = new Logger(db);
+  const cache = new Cache();
+  
+  // Search across all music entities
+  async function search(req, res) {
+    try {
+      const { query, type, limit = 10 } = req.query;
+      
+      if (!query || query.length < 2) {
+        return res.status(400).json({ error: 'Search query must be at least 2 characters' });
+      }
+      
+      const limitNum = parseInt(limit, 10);
+      const cacheKey = `search:${query}:${type || 'all'}:${limitNum}`;
+      
+      // Try to get from cache first
+      let results = await cache.get(cacheKey);
+      
+      if (!results) {
+        results = {};
+        
+        // Create text search regex
+        const searchRegex = new RegExp(query, 'i');
+        
+        // Filter queries based on type
+        const types = type ? [type] : ['tracks', 'albums', 'artists', 'playlists', 'genres'];
+        
+        // Perform search for each requested type
+        if (types.includes('tracks') || types.includes('all')) {
+          results.tracks = await db.track.find({
+            $or: [
+              { title: searchRegex },
+              { tags: searchRegex }
+            ],
+            status: 'published',
+            isPublic: true
+          }).limit(limitNum);
+        }
+        
+        if (types.includes('albums') || types.includes('all')) {
+          results.albums = await db.album.find({
+            $or: [
+              { title: searchRegex },
+              { description: searchRegex },
+              { tags: searchRegex }
+            ],
+            status: 'published',
+            isPublic: true
+          }).limit(limitNum);
+        }
+        
+        if (types.includes('artists') || types.includes('all')) {
+          results.artists = await db.artist.find({
+            $or: [
+              { name: searchRegex },
+              { bio: searchRegex },
+              { tags: searchRegex }
+            ],
+            status: 'published'
+          }).limit(limitNum);
+        }
+        
+        if (types.includes('playlists') || types.includes('all')) {
+          results.playlists = await db.playlist.find({
+            $or: [
+              { title: searchRegex },
+              { description: searchRegex },
+              { tags: searchRegex }
+            ],
+            isPublic: true
+          }).limit(limitNum);
+        }
+        
+        if (types.includes('genres') || types.includes('all')) {
+          results.genres = await db.genre.find({
+            $or: [
+              { name: searchRegex },
+              { description: searchRegex }
+            ],
+            status: 'published'
+          }).limit(limitNum);
+        }
+        
+        // Cache results for 10 minutes
+        await cache.set(cacheKey, results, 600);
+      }
+      
+      res.json(results);
+    } catch (error) {
+      logger.error(`Error searching: ${error.message}`);
+      res.status(500).json({ error: error.message });
+    }
+  }
+  
+  return {
+    search
+  };
+};

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

@@ -0,0 +1,106 @@
+// controllers/stream.controller.js
+const path = require('path');
+const fs = require('fs');
+
+module.exports = function(app,db,publicPath) {
+  const Logger = require('@martyrs/src/modules/globals/controllers/classes/globals.logger');
+  const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js');
+  
+  const logger = new Logger(db);
+  const abac = getInstance(db);
+  
+  // Stream track audio
+  async function streamAudio(req, res) {
+    try {
+      const trackId = req.params.trackId;
+      
+      // Find track
+      const track = await db.track.findById(trackId);
+      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'
+        });
+      }
+      
+      // Extract file path from fileUrl
+      const fileUrl = track.fileUrl;
+      console.log('public is', publicPath)
+      const filePath = path.join(publicPath, fileUrl);
+      
+      // Check if file exists
+      if (!fs.existsSync(filePath)) {
+        logger.error(`File not found: ${filePath}`);
+        return res.status(404).json({ error: 'Audio file not found' });
+      }
+      
+      // Get file stats
+      const stat = fs.statSync(filePath);
+      const fileSize = stat.size;
+      const range = req.headers.range;
+      
+      // Log play history if user is authenticated
+      if (req.userId) {
+        try {
+          await db.playHistory.create({
+            user: req.userId,
+            track: trackId,
+            playedAt: new Date(),
+            deviceInfo: req.headers['user-agent'],
+            playedFrom: req.query.from || 'other',
+            contextId: req.query.contextId || null
+          });
+          
+          // Increment playCount
+          await db.track.findByIdAndUpdate(trackId, { $inc: { playCount: 1 } });
+        } catch (error) {
+          logger.error(`Error logging play history: ${error.message}`);
+        }
+      }
+      
+      // Handle range requests for audio streaming
+      if (range) {
+        const parts = range.replace(/bytes=/, '').split('-');
+        const start = parseInt(parts[0], 10);
+        const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
+        const chunksize = (end - start) + 1;
+        const file = fs.createReadStream(filePath, { start, end });
+        
+        res.writeHead(206, {
+          'Content-Range': `bytes ${start}-${end}/${fileSize}`,
+          'Accept-Ranges': 'bytes',
+          'Content-Length': chunksize,
+          'Content-Type': 'audio/mpeg'
+        });
+        
+        file.pipe(res);
+      } else {
+        res.writeHead(200, {
+          'Content-Length': fileSize,
+          'Content-Type': 'audio/mpeg'
+        });
+        
+        fs.createReadStream(filePath).pipe(res);
+      }
+    } catch (error) {
+      logger.error(`Error streaming audio: ${error.message}`);
+      res.status(500).json({ error: error.message });
+    }
+  }
+  
+  return {
+    streamAudio
+  };
+};

package/src/modules/music/models/album.model.js

@@ -0,0 +1,61 @@
+const applyOwnershipSchema = require('@martyrs/src/modules/globals/models/schemas/ownership.schema.js');
+const applyMetadataSchema = require('@martyrs/src/modules/globals/models/schemas/metadata.schema.js');
+const applyCommonSchema = require('@martyrs/src/modules/globals/models/schemas/common.schema.js');
+const applyEngagementSchema = require('@martyrs/src/modules/globals/models/schemas/engagement.schema.js');
+
+module.exports = function(db) {
+  const albumSchema = new db.mongoose.Schema({
+    title: {
+      type: String,
+      required: true
+    },
+    description: {
+      type: String,
+      default: ''
+    },
+    releaseDate: {
+      type: Date,
+      required: true
+    },
+    coverArt: {
+      type: String,
+      default: null
+    },
+    artists: [{
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: 'Artist',
+      required: true
+    }],
+    type: {
+      type: String,
+      enum: ['album', 'single', 'EP', 'compilation'],
+      default: 'album'
+    },
+    genres: [{
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: 'Genre'
+    }],
+    totalTracks: {
+      type: Number,
+      default: 0
+    }
+  }, { 
+    timestamps: true,
+    versionKey: false
+  });
+
+  // Apply global schemas
+  applyOwnershipSchema(albumSchema, db);
+  applyMetadataSchema(albumSchema, db);
+  applyCommonSchema(albumSchema, db);
+  applyEngagementSchema(albumSchema, db);
+
+  // Indexing
+  albumSchema.index({ title: 'text', description: 'text' });
+  albumSchema.index({ 'artists': 1 });
+  albumSchema.index({ 'releaseDate': -1 });
+  albumSchema.index({ 'type': 1 });
+  albumSchema.index({ 'genres': 1 });
+
+  return db.mongoose.models.Album || db.mongoose.model('Album', albumSchema);
+};

package/src/modules/music/models/artist.model.js

@@ -0,0 +1,67 @@
+// models/artist.model.js
+module.exports = function(db) {
+  const mongoose = db.mongoose;
+  const Schema = mongoose.Schema;
+
+  // Apply common schemas
+  const applyCommonSchema = require('@martyrs/src/modules/globals/models/schemas/common.schema.js');
+  const applyMetadataSchema = require('@martyrs/src/modules/globals/models/schemas/metadata.schema.js');
+  const applyOwnershipSchema = require('@martyrs/src/modules/globals/models/schemas/ownership.schema.js');
+  const applySocialsSchema = require('@martyrs/src/modules/globals/models/schemas/socials.schema.js');
+  const applyEngagementSchema = require('@martyrs/src/modules/globals/models/schemas/engagement.schema.js');
+
+  const ArtistSchema = new Schema({
+    name: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    bio: {
+      type: String,
+      trim: true
+    },
+    photoUrl: {
+      type: String
+    },
+    coverUrl: {
+      type: String
+    },
+    genre: [{
+      type: Schema.Types.ObjectId,
+      ref: 'Genre'
+    }],
+    isVerified: {
+      type: Boolean,
+      default: false
+    },
+    website: {
+      type: String,
+      trim: true
+    },
+    location: {
+      type: String,
+      trim: true
+    },
+    popularity: {
+      type: Number,
+      default: 0
+    }
+  }, {
+    timestamps: true,
+    versionKey: false
+  });
+
+  // Apply common schemas
+  applyCommonSchema(ArtistSchema, db);
+  applyMetadataSchema(ArtistSchema, db);
+  applyOwnershipSchema(ArtistSchema, db);
+  applySocialsSchema(ArtistSchema, db);
+  applyEngagementSchema(ArtistSchema, db);
+
+  // Create indexes
+  ArtistSchema.index({ name: 'text', bio: 'text' });
+  ArtistSchema.index({ popularity: -1 });
+  ArtistSchema.index({ isVerified: 1 });
+  
+  return mongoose.models.Artist || mongoose.model('Artist', ArtistSchema);
+};