@ozdao/martyrs 0.2.469 → 0.2.471

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

@@ -0,0 +1,42 @@
+// models/genre.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 GenreSchema = new Schema({
+    name: {
+      type: String,
+      required: true,
+      trim: true,
+      unique: true
+    },
+    description: {
+      type: String,
+      trim: true
+    },
+    iconUrl: {
+      type: String
+    },
+    popularity: {
+      type: Number,
+      default: 0
+    }
+  }, {
+    timestamps: true,
+    versionKey: false
+  });
+
+  // Apply common schemas
+  applyCommonSchema(GenreSchema, db);
+  applyMetadataSchema(GenreSchema, db);
+
+  // Create indexes
+  GenreSchema.index({ name: 'text', description: 'text' });
+  GenreSchema.index({ popularity: -1 });
+  
+  return mongoose.models.Genre || mongoose.model('Genre', GenreSchema);
+};

package/src/modules/music/models/play-history.model.js

@@ -0,0 +1,51 @@
+// models/play-history.model.js
+module.exports = function(db) {
+  const mongoose = db.mongoose;
+  const Schema = mongoose.Schema;
+
+  const PlayHistorySchema = new Schema({
+    user: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+      required: true
+    },
+    track: {
+      type: Schema.Types.ObjectId,
+      ref: 'Track',
+      required: true
+    },
+    playedAt: {
+      type: Date,
+      default: Date.now
+    },
+    playDuration: {
+      type: Number,
+      default: 0
+    },
+    playedFrom: {
+      type: String,
+      enum: ['playlist', 'album', 'search', 'recommendation', 'artist', 'other'],
+      default: 'other'
+    },
+    contextId: {
+      type: Schema.Types.ObjectId,
+      refPath: 'playedFrom'
+    },
+    deviceInfo: {
+      type: String
+    },
+    location: {
+      type: String
+    }
+  }, {
+    timestamps: true,
+    versionKey: false
+  });
+
+  // Create indexes
+  PlayHistorySchema.index({ user: 1, playedAt: -1 });
+  PlayHistorySchema.index({ track: 1 });
+  PlayHistorySchema.index({ playedAt: -1 });
+  
+  return mongoose.models.PlayHistory || mongoose.model('PlayHistory', PlayHistorySchema);
+};

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

@@ -0,0 +1,69 @@
+// models/playlist.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 applyEngagementSchema = require('@martyrs/src/modules/globals/models/schemas/engagement.schema.js');
+
+  const PlaylistSchema = new Schema({
+    title: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    description: {
+      type: String,
+      trim: true
+    },
+    coverUrl: {
+      type: String
+    },
+    tracks: [{
+      track: {
+        type: Schema.Types.ObjectId,
+        ref: 'Track'
+      },
+      addedAt: {
+        type: Date,
+        default: Date.now
+      }
+    }],
+    isPublic: {
+      type: Boolean,
+      default: true
+    },
+    followers: {
+      type: Number,
+      default: 0
+    },
+    isCollaborative: {
+      type: Boolean,
+      default: false
+    },
+    collaborators: [{
+      type: Schema.Types.ObjectId,
+      ref: 'User'
+    }]
+  }, {
+    timestamps: true,
+    versionKey: false
+  });
+
+  // Apply common schemas
+  applyCommonSchema(PlaylistSchema, db);
+  applyMetadataSchema(PlaylistSchema, db);
+  applyOwnershipSchema(PlaylistSchema, db);
+  applyEngagementSchema(PlaylistSchema, db);
+
+  // Create indexes
+  PlaylistSchema.index({ title: 'text', description: 'text' });
+  PlaylistSchema.index({ isPublic: 1 });
+  PlaylistSchema.index({ followers: -1 });
+  PlaylistSchema.index({ 'tracks.addedAt': -1 });
+  
+  return mongoose.models.Playlist || mongoose.model('Playlist', PlaylistSchema);
+};

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

@@ -0,0 +1,94 @@
+// models/track.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 applyEngagementSchema = require('@martyrs/src/modules/globals/models/schemas/engagement.schema.js');
+
+  const TrackSchema = new Schema({
+    title: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    artist: {
+      type: Schema.Types.ObjectId,
+      ref: 'Artist',
+      required: true
+    },
+    album: {
+      type: Schema.Types.ObjectId,
+      ref: 'Album'
+    },
+    duration: {
+      type: Number,
+      default: 0
+    },
+    fileUrl: {
+      type: String,
+      required: true
+    },
+    coverUrl: {
+      type: String
+    },
+    genre: [{
+      type: Schema.Types.ObjectId,
+      ref: 'Genre'
+    }],
+    releaseDate: {
+      type: Date,
+      default: Date.now
+    },
+    isExplicit: {
+      type: Boolean,
+      default: false
+    },
+    lyrics: {
+      type: String
+    },
+    playCount: {
+      type: Number,
+      default: 0
+    },
+    isPublic: {
+      type: Boolean,
+      default: true
+    }
+  }, {
+    timestamps: true,
+    versionKey: false
+  });
+
+  // Apply common schemas
+  applyCommonSchema(TrackSchema, db);
+  applyMetadataSchema(TrackSchema, db);
+  applyOwnershipSchema(TrackSchema, db);
+  applyEngagementSchema(TrackSchema, db);
+
+  // Create indexes for efficient querying
+  TrackSchema.index({ title: 'text' });
+  TrackSchema.index({ artist: 1 });
+  TrackSchema.index({ album: 1 });
+  TrackSchema.index({ releaseDate: -1 });
+  TrackSchema.index({ playCount: -1 });
+
+  // Pre-save middleware to create a URL if not provided
+  TrackSchema.pre('save', function(next) {
+    if (!this.url) {
+      const createFriendlyURL = require('@martyrs/src/modules/globals/controllers/utils/seo-friendly-url');
+      this.url = createFriendlyURL(`${this.title}-${this._id}`);
+    }
+    next();
+  });
+
+  // Virtual for artist name (useful for APIs)
+  TrackSchema.virtual('artistName').get(function() {
+    return this.artist ? this.artist.name : '';
+  });
+
+  return mongoose.models.Track || mongoose.model('Track', TrackSchema);
+};

package/src/modules/music/music.client.js

@@ -0,0 +1,186 @@
+// Store modules
+import * as storeTracks from './store/tracks.js';
+import * as storePlaylists from './store/playlists.js';
+import * as storeAlbums from './store/albums.js';
+import * as storeArtists from './store/artists.js';
+import * as storePlayer from './store/player.js';
+import * as storeSearch from './store/search.js';
+
+// Router
+import routerMusic from './router/music';
+
+// Layouts
+import MusicLayout from './components/layouts/MusicLayout.vue';
+
+// Pages
+import MusicHome from './components/pages/MusicHome.vue';
+import SearchResults from './components/pages/SearchResults.vue';
+import ArtistDetail from './components/pages/ArtistDetail.vue';
+import AlbumDetail from './components/pages/AlbumDetail.vue';
+import PlaylistDetail from './components/pages/PlaylistDetail.vue';
+import TrackDetail from './components/pages/TrackDetail.vue';
+import MusicLibrary from './components/pages/MusicLibrary.vue';
+import MusicUpload from './components/pages/MusicUpload.vue';
+
+// Components - Player
+import MusicPlayer from './components/player/MusicPlayer.vue';
+import TrackProgress from './components/player/TrackProgress.vue';
+import VolumeControl from './components/player/VolumeControl.vue';
+
+// Components - Cards
+import TrackCard from './components/cards/TrackCard.vue';
+import AlbumCard from './components/cards/AlbumCard.vue';
+import PlaylistCard from './components/cards/PlaylistCard.vue';
+import ArtistCard from './components/cards/ArtistCard.vue';
+
+// Components - Lists
+import TrackList from './components/lists/TrackList.vue';
+import AlbumList from './components/lists/AlbumList.vue';
+import PlaylistList from './components/lists/PlaylistList.vue';
+import ArtistList from './components/lists/ArtistList.vue';
+
+// Components - Forms
+import PlaylistForm from './components/forms/PlaylistForm.vue';
+import SearchForm from './components/forms/SearchForm.vue';
+import UploadForm from './components/forms/UploadForm.vue';
+
+// WebSocket integration for streaming
+import globalWebSocket from '@martyrs/src/modules/globals/views/classes/globals.websocket.js';
+
+/**
+ * Initialize Music module on client-side
+ * @param {Object} app - Vue app instance
+ * @param {Object} store - Global store instance
+ * @param {Object} router - Vue router instance
+ * @param {Object} config - Configuration options
+ * @param {Object} options - Additional options
+ */
+function initializeMusic(app, store, router, config, options = {}) {
+  const route = options.route || 'Home';
+
+  // Register routes
+  router.addRoute(route, routerMusic);
+  
+  // Register store modules
+  store.addStore('tracks', storeTracks);
+  store.addStore('playlists', storePlaylists);
+  store.addStore('albums', storeAlbums);
+  store.addStore('artists', storeArtists);
+  store.addStore('player', storePlayer);
+  store.addStore('search', storeSearch);
+  
+  // Set up WebSocket subscription for music streaming
+  if (options.enableStreaming !== false && app.config.globalProperties.WSS_URL) {
+    globalWebSocket.initialize({ 
+      wsUrl: app.config.globalProperties.WSS_URL,
+      maxReconnectAttempts: 10,
+      reconnectDelay: 2000
+    });
+    
+    // Subscribe to music streaming module when authenticated
+    if (options.userId) {
+      globalWebSocket.connect(options.userId).then(() => {
+        globalWebSocket.subscribeModule('music-streaming');
+      }).catch(err => {
+        console.error('Failed to connect to WebSocket for music streaming:', err);
+      });
+    }
+  }
+  
+  // Register global components if needed
+  app.component('MusicPlayer', MusicPlayer);
+}
+
+// Module export
+const ModuleMusic = {
+  initialize: initializeMusic,
+  views: {
+    store: {
+      storeTracks,
+      storePlaylists,
+      storeAlbums,
+      storeArtists,
+      storePlayer,
+      storeSearch
+    },
+    router: {
+      routerMusic
+    },
+    components: {
+      // Layouts
+      MusicLayout,
+      // Pages
+      MusicHome,
+      SearchResults,
+      ArtistDetail,
+      AlbumDetail,
+      PlaylistDetail,
+      TrackDetail,
+      MusicLibrary,
+      MusicUpload,
+      // Player Components
+      MusicPlayer,
+      TrackProgress,
+      VolumeControl,
+      // Cards
+      TrackCard,
+      AlbumCard,
+      PlaylistCard,
+      ArtistCard,
+      // Lists
+      TrackList,
+      AlbumList,
+      PlaylistList,
+      ArtistList,
+      // Forms
+      PlaylistForm,
+      SearchForm,
+      UploadForm,
+    }
+  }
+};
+
+// Named exports for direct component imports
+export {
+  // Layout
+  MusicLayout,
+  // Pages
+  MusicHome,
+  SearchResults,
+  ArtistDetail,
+  AlbumDetail,
+  PlaylistDetail,
+  TrackDetail,
+  MusicLibrary,
+  MusicUpload,
+  // Player Components
+  MusicPlayer,
+  TrackProgress,
+  VolumeControl,
+  // Cards
+  TrackCard,
+  AlbumCard,
+  PlaylistCard,
+  ArtistCard,
+  // Lists
+  TrackList,
+  AlbumList,
+  PlaylistList,
+  ArtistList,
+  // Forms
+  PlaylistForm,
+  SearchForm,
+  UploadForm,
+  // Store modules
+  storeTracks,
+  storePlaylists,
+  storeAlbums,
+  storeArtists,
+  storePlayer,
+  storeSearch,
+  // Router
+  routerMusic
+};
+
+// Default export
+export default ModuleMusic;

package/src/modules/music/music.server.js

@@ -0,0 +1,114 @@
+// music.server.js (update)
+const MusicController = require('./controllers/music.controller.js');
+const PlaylistController = require('./controllers/playlist.controller.js');
+const AlbumController = require('./controllers/album.controller.js');
+const ArtistController = require('./controllers/artist.controller.js');
+const StreamController = require('./controllers/stream.controller.js');
+const SearchController = require('./controllers/search.controller.js');
+const GenreController = require('./controllers/genre.controller.js');
+
+// Import routes
+const musicRoutes = require('./routes/music.routes.js');
+const playlistRoutes = require('./routes/playlist.routes.js');
+const albumRoutes = require('./routes/album.routes.js');
+const artistRoutes = require('./routes/artist.routes.js');
+const streamRoutes = require('./routes/stream.routes.js');
+const searchRoutes = require('./routes/search.routes.js');
+const genreRoutes = require('./routes/genre.routes.js');
+
+// Import models
+const TrackModel = require('./models/track.model.js');
+const PlaylistModel = require('./models/playlist.model.js');
+const AlbumModel = require('./models/album.model.js');
+const ArtistModel = require('./models/artist.model.js');
+const GenreModel = require('./models/genre.model.js');
+const PlayHistoryModel = require('./models/play-history.model.js');
+
+// Import WebSocket handlers
+const StreamingHandler = require('./websocket/streaming.handler.js');
+
+// Import ABAC policies
+const musicPolicies = require('./policies/music.policies.js');
+
+/**
+ * Initialize the Music module
+ * @param {Object} app - Express application instance
+ * @param {Object} db - Database connection object
+ * @param {Array} origins - CORS allowed origins
+ * @param {String} publicPath - Path to public files
+ */
+function initializeMusic({app, db, wss, origins, publicPath}) {
+  // Register models in the database object
+  db.track = TrackModel(db);
+  db.playlist = PlaylistModel(db);
+  db.album = AlbumModel(db);
+  db.artist = ArtistModel(db);
+  db.genre = GenreModel(db);
+  db.playHistory = PlayHistoryModel(db);
+
+    console.log('server publioc is', publicPath)
+
+  // Set up routes if app is provided
+  if (app) {
+    musicRoutes(app, db, origins, publicPath);
+    playlistRoutes(app, db, origins, publicPath);
+    albumRoutes(app, db, origins, publicPath);
+    artistRoutes(app, db, origins, publicPath);
+    streamRoutes(app, db, origins, publicPath);
+    searchRoutes(app, db, origins, publicPath);
+    genreRoutes(app, db, origins, publicPath);
+  }
+
+  // Initialize ABAC policies for music module
+  const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js');
+  const abac = getInstance(db);
+  musicPolicies(abac);
+
+  // Set up WebSocket handlers if WebSocketManager is available
+  const { WebSocketManager } = require('@martyrs/src/modules/globals/controllers/classes/globals.websocket.js');
+  if (global.webSocketManager && global.webSocketManager instanceof WebSocketManager) {
+    global.webSocketManager.registerModule('music-streaming', StreamingHandler(db).handleStreamingMessage);
+  }
+
+  // Initialize cache for frequently accessed data
+  const Cache = require('@martyrs/src/modules/globals/controllers/classes/globals.cache');
+  const musicCache = new Cache({ ttlSeconds: 60 * 15 }); // 15 minute cache
+
+  // Initialize logger for music-specific logs
+  const Logger = require('@martyrs/src/modules/globals/controllers/classes/globals.logger');
+  const musicLogger = new Logger(db);
+
+  // Log module initialization
+  musicLogger.info('Music module initialized');
+}
+
+// Export initialization function, controllers, routes, and models
+module.exports = {
+  initialize: initializeMusic,
+  models: {
+    TrackModel,
+    PlaylistModel,
+    AlbumModel,
+    ArtistModel,
+    GenreModel,
+    PlayHistoryModel
+  },
+  routes: {
+    musicRoutes,
+    playlistRoutes,
+    albumRoutes,
+    artistRoutes,
+    streamRoutes,
+    searchRoutes,
+    genreRoutes
+  },
+  controllers: {
+    MusicController,
+    PlaylistController,
+    AlbumController,
+    ArtistController,
+    StreamController,
+    SearchController,
+    GenreController
+  }
+};

package/src/modules/music/policies/music.policies.js

@@ -0,0 +1,84 @@
+// policies/music.policies.js
+module.exports = function initializeMusicPolicies(abacAccessControl) {
+  // Policy for handling music resource ownership
+  abacAccessControl.registerResourcePolicy('tracks', async (context) => {
+    const { user, action, currentResource, resourceModel } = context;
+    const ObjectId = abacAccessControl.db.mongoose.Types.ObjectId;
+    
+    // Allow public read access for published tracks
+    if (action === 'read' && currentResource?.status === 'published' && currentResource?.isPublic === true) {
+      return true;
+    }
+    
+    // For create actions, verify ownership
+    if (action === 'create') {
+      // Ensure that creator.target matches the authenticated user
+      if (context.data.creator && context.data.creator.target) {
+        return context.data.creator.target.toString() === user.toString();
+      }
+      return false;
+    }
+    
+    // For update and delete, verify ownership
+    if (['update', 'edit', 'delete'].includes(action) && currentResource) {
+      // If the resource has an organization owner, check if user belongs to that organization
+      if (currentResource.owner && currentResource.owner.type === 'Organization') {
+        // Here you would typically check if the user is part of the organization
+        // This would require a query to the organization's members
+        const Organization = abacAccessControl.db.organization;
+        const org = await Organization.findOne({
+          _id: currentResource.owner.target,
+          members: { $elemMatch: { user: new ObjectId(user) } }
+        });
+        
+        if (org) return true;
+      }
+      
+      // Check if the user is the creator
+      if (currentResource.creator && 
+          currentResource.creator.target && 
+          currentResource.creator.target.toString() === user.toString()) {
+        return true;
+      }
+      
+      return false;
+    }
+    
+    // Default access denied
+    return false;
+  });
+  
+  // Apply the same policies to albums
+  abacAccessControl.registerResourcePolicy('albums', async (context) => {
+    // Reuse the track policy logic
+    return abacAccessControl.policies.resources.tracks(context);
+  });
+  
+  // Apply the same policies to playlists
+  abacAccessControl.registerResourcePolicy('playlists', async (context) => {
+    const { user, action, currentResource } = context;
+    
+    // Special case for collaborative playlists
+    if (currentResource && currentResource.isCollaborative && 
+        currentResource.collaborators && 
+        currentResource.collaborators.some(collaborator => 
+          collaborator.toString() === user.toString()
+        )) {
+      // Collaborators can edit but not delete
+      if (action === 'edit' || action === 'update') {
+        return true;
+      }
+    }
+    
+    // For other cases, reuse the track policy logic
+    return abacAccessControl.policies.resources.tracks(context);
+  });
+  
+  // Apply the same policies to artists
+  abacAccessControl.registerResourcePolicy('artists', async (context) => {
+    // Reuse the track policy logic
+    return abacAccessControl.policies.resources.tracks(context);
+  });
+  
+  return abacAccessControl;
+};