@ozdao/martyrs 0.2.484 → 0.2.486

package/dist/music.server.js

@@ -0,0 +1,1407 @@
+import { g as globalsabac } from "./globals.abac-DBV_kaOq.js";
+import { L as Logger, C as Cache } from "./globals.logger-Bf6rRU7j.js";
+import { W as WebSocketManager } from "./globals.websocket-DzvdIBf6.js";
+import { C as CRUD } from "./globals.crud-BQG1Lm0A.js";
+import fs$1 from "fs";
+import path$1 from "path";
+import { a as applyCommonSchema } from "./common.schema-Bw1O5_2Q.js";
+import { a as applyEngagementSchema } from "./engagement.schema-Dh1adRsn.js";
+import { a as applyMetadataSchema, c as createFriendlyURL } from "./metadata.schema-CWmcDJN7.js";
+import { a as applyOwnershipSchema } from "./ownership.schema-CCZX5vfw.js";
+import { a as applySocialsSchema } from "./socials.schema-BOZV82Mp.js";
+import { m as middlewareIndexFactory } from "./index-CsJwdsBW.js";
+const { getInstance: getInstance$1 } = globalsabac;
+const MusicController = function(app, db) {
+  const logger = new Logger(db);
+  const cache = new Cache();
+  const abac = getInstance$1(db);
+  class MusicController2 extends CRUD {
+    constructor(basePath, app2, db2, model, options) {
+      super(basePath, app2, db2, model, options);
+      this.logger = logger;
+      this.cache = cache;
+      this.abac = abac;
+    }
+    // Override the create method to handle ownership
+    async create(req, res) {
+      try {
+        console.log(`[MusicController] Create request received:`, {
+          userId: req.userId,
+          body: req.body
+        });
+        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"
+          });
+        }
+        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`);
+        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);
+        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" });
+        }
+        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"
+          });
+        }
+        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" });
+        }
+        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"
+          });
+        }
+        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: MusicController2
+  };
+};
+const AlbumController = function(app, db) {
+  const { MusicController: MusicController$1 } = MusicController(app, db);
+  class AlbumController2 extends MusicController$1 {
+    constructor(app2) {
+      super("/api/albums", app2, db, db.album);
+    }
+    // Get tracks for a specific album
+    async getAlbumTracks(req, res) {
+      try {
+        const albumId = req.params.albumId;
+        const album = await db.album.findById(albumId);
+        if (!album) {
+          return res.status(404).json({ error: "Album not found" });
+        }
+        const accessResult = await this.abac.checkAccess({
+          user: req.userId,
+          resource: "albums",
+          action: "read",
+          currentResource: album
+        });
+        if (!accessResult.allowed && !album.isPublic) {
+          return res.status(403).json({
+            errorCode: accessResult.reason,
+            message: "Access Denied"
+          });
+        }
+        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) {
+          featuredAlbums = await db.album.aggregate([
+            { $match: { status: "featured", isPublic: true } },
+            {
+              $lookup: {
+                from: "tracks",
+                localField: "_id",
+                foreignField: "album",
+                as: "tracks"
+              }
+            },
+            {
+              $addFields: {
+                trackCount: { $size: "$tracks" }
+              }
+            },
+            { $project: { tracks: 0 } },
+            { $sort: { releaseDate: -1 } },
+            { $limit: 10 }
+          ]);
+          await this.cache.set(cacheKey, featuredAlbums, 3600);
+        }
+        res.json(featuredAlbums);
+      } catch (error) {
+        this.logger.error(`Error getting featured albums: ${error.message}`);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  }
+  const albumController = new AlbumController2(app, db);
+  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)
+  };
+};
+const ArtistController = function(app, db) {
+  const { MusicController: MusicController$1 } = MusicController(app, db);
+  class ArtistController2 extends MusicController$1 {
+    constructor(app2) {
+      super("/api/artists", app2, db, db.artist);
+    }
+    // Get artist discography
+    async getDiscography(req, res) {
+      try {
+        const artistId = req.params.artistId;
+        const artist = await db.artist.findById(artistId);
+        if (!artist) {
+          return res.status(404).json({ error: "Artist not found" });
+        }
+        const albums = await db.album.find({
+          artist: artistId,
+          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
+        });
+      } 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;
+        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;
+        const artist = await db.artist.findById(artistId);
+        if (!artist) {
+          return res.status(404).json({ error: "Artist not found" });
+        }
+        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}`);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  }
+  const artistController = new ArtistController2(app, db);
+  return {
+    create: artistController.create.bind(artistController),
+    read: artistController.read.bind(artistController),
+    update: artistController.update.bind(artistController),
+    delete: artistController.delete.bind(artistController),
+    getDiscography: artistController.getDiscography.bind(artistController),
+    verifyArtist: artistController.verifyArtist.bind(artistController),
+    getRelatedArtists: artistController.getRelatedArtists.bind(artistController)
+  };
+};
+const GenreController = function(app, db) {
+  const { MusicController: MusicController$1 } = MusicController(app, db);
+  class GenreController2 extends MusicController$1 {
+    constructor(app2) {
+      super("/api/genres", app2, db, db.genre);
+    }
+    // Get tracks by genre
+    async getGenreTracks(req, res) {
+      try {
+        const genreId = req.params.genreId;
+        const genre = await db.genre.findById(genreId);
+        if (!genre) {
+          return res.status(404).json({ error: "Genre not found" });
+        }
+        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
+        });
+      } 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);
+        res.json(genres);
+      } catch (error) {
+        this.logger.error(`Error getting popular genres: ${error.message}`);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  }
+  const genreController = new GenreController2(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)
+  };
+};
+const PlaylistController = function(app, db) {
+  const { MusicController: MusicController$1 } = MusicController(app, db);
+  class PlaylistController2 extends MusicController$1 {
+    constructor(app2, db2) {
+      super("/api/playlists", app2, db2, db2.playlist);
+    }
+    // Add track to playlist
+    async addTrack(req, res) {
+      try {
+        const { playlistId, trackId } = req.params;
+        const playlist = await db.playlist.findById(playlistId);
+        if (!playlist) {
+          return res.status(404).json({ error: "Playlist not found" });
+        }
+        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"
+          });
+        }
+        const track = await db.track.findById(trackId);
+        if (!track) {
+          return res.status(404).json({ error: "Track not found" });
+        }
+        const trackExists = playlist.tracks.some((item) => item.track.toString() === trackId);
+        if (trackExists) {
+          return res.status(400).json({ error: "Track already in playlist" });
+        }
+        playlist.tracks.push({
+          track: trackId,
+          addedAt: /* @__PURE__ */ 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;
+        const playlist = await db.playlist.findById(playlistId);
+        if (!playlist) {
+          return res.status(404).json({ error: "Playlist not found" });
+        }
+        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"
+          });
+        }
+        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;
+        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;
+        const playlist = await db.playlist.findById(playlistId);
+        if (!playlist) {
+          return res.status(404).json({ error: "Playlist not found" });
+        }
+        if (playlist.owner.target.toString() !== req.userId) {
+          return res.status(403).json({ error: "Only playlist owner can add collaborators" });
+        }
+        const user = await db.mongoose.model("User").findById(userId);
+        if (!user) {
+          return res.status(404).json({ error: "User not found" });
+        }
+        if (playlist.collaborators.includes(userId)) {
+          return res.status(400).json({ error: "User is already a 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 PlaylistController2(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)
+  };
+};
+const SearchController = function(app, db) {
+  const logger = new Logger(db);
+  const cache = new Cache();
+  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}`;
+      let results = await cache.get(cacheKey);
+      if (!results) {
+        results = {};
+        const searchRegex = new RegExp(query, "i");
+        const types = type ? [type] : ["tracks", "albums", "artists", "playlists", "genres"];
+        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);
+        }
+        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
+  };
+};
+const StreamController = function(app, db, publicPath) {
+  const { getInstance: getInstance2 } = globalsabac;
+  const logger = new Logger(db);
+  const abac = getInstance2(db);
+  async function streamAudio(req, res) {
+    try {
+      const trackId = req.params.trackId;
+      const track = await db.track.findById(trackId);
+      if (!track) {
+        return res.status(404).json({ error: "Track not found" });
+      }
+      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"
+        });
+      }
+      const fileUrl = track.fileUrl;
+      console.log("public is", publicPath);
+      const filePath = path$1.join(publicPath, fileUrl);
+      if (!fs$1.existsSync(filePath)) {
+        logger.error(`File not found: ${filePath}`);
+        return res.status(404).json({ error: "Audio file not found" });
+      }
+      const stat = fs$1.statSync(filePath);
+      const fileSize = stat.size;
+      const range = req.headers.range;
+      if (req.userId) {
+        try {
+          await db.playHistory.create({
+            user: req.userId,
+            track: trackId,
+            playedAt: /* @__PURE__ */ new Date(),
+            deviceInfo: req.headers["user-agent"],
+            playedFrom: req.query.from || "other",
+            contextId: req.query.contextId || null
+          });
+          await db.track.findByIdAndUpdate(trackId, { $inc: { playCount: 1 } });
+        } catch (error) {
+          logger.error(`Error logging play history: ${error.message}`);
+        }
+      }
+      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$1.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$1.createReadStream(filePath).pipe(res);
+      }
+    } catch (error) {
+      logger.error(`Error streaming audio: ${error.message}`);
+      res.status(500).json({ error: error.message });
+    }
+  }
+  return {
+    streamAudio
+  };
+};
+const AlbumModel = 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
+    }
+  );
+  applyOwnershipSchema(albumSchema, db);
+  applyMetadataSchema(albumSchema);
+  applyCommonSchema(albumSchema);
+  applyEngagementSchema(albumSchema);
+  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);
+};
+const ArtistModel = function(db) {
+  const mongoose = db.mongoose;
+  const Schema = mongoose.Schema;
+  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
+    }
+  );
+  applyCommonSchema(ArtistSchema);
+  applyMetadataSchema(ArtistSchema);
+  applyOwnershipSchema(ArtistSchema, db);
+  applySocialsSchema(ArtistSchema);
+  applyEngagementSchema(ArtistSchema);
+  ArtistSchema.index({ name: "text", bio: "text" });
+  ArtistSchema.index({ popularity: -1 });
+  ArtistSchema.index({ isVerified: 1 });
+  return mongoose.models.Artist || mongoose.model("Artist", ArtistSchema);
+};
+const GenreModel = function(db) {
+  const mongoose = db.mongoose;
+  const Schema = mongoose.Schema;
+  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
+    }
+  );
+  applyCommonSchema(GenreSchema);
+  applyMetadataSchema(GenreSchema);
+  GenreSchema.index({ name: "text", description: "text" });
+  GenreSchema.index({ popularity: -1 });
+  return mongoose.models.Genre || mongoose.model("Genre", GenreSchema);
+};
+const PlayHistoryModel = 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
+    }
+  );
+  PlayHistorySchema.index({ user: 1, playedAt: -1 });
+  PlayHistorySchema.index({ track: 1 });
+  PlayHistorySchema.index({ playedAt: -1 });
+  return mongoose.models.PlayHistory || mongoose.model("PlayHistory", PlayHistorySchema);
+};
+const PlaylistModel = function(db) {
+  const mongoose = db.mongoose;
+  const Schema = mongoose.Schema;
+  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
+    }
+  );
+  applyCommonSchema(PlaylistSchema);
+  applyMetadataSchema(PlaylistSchema);
+  applyOwnershipSchema(PlaylistSchema, db);
+  applyEngagementSchema(PlaylistSchema);
+  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);
+};
+const TrackModel = function(db) {
+  const mongoose = db.mongoose;
+  const Schema = mongoose.Schema;
+  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
+    }
+  );
+  applyCommonSchema(TrackSchema);
+  applyMetadataSchema(TrackSchema);
+  applyOwnershipSchema(TrackSchema, db);
+  applyEngagementSchema(TrackSchema);
+  TrackSchema.index({ title: "text" });
+  TrackSchema.index({ artist: 1 });
+  TrackSchema.index({ album: 1 });
+  TrackSchema.index({ releaseDate: -1 });
+  TrackSchema.index({ playCount: -1 });
+  TrackSchema.pre("save", function(next) {
+    if (!this.url) {
+      this.url = createFriendlyURL(`${this.title}-${this._id}`);
+    }
+    next();
+  });
+  TrackSchema.virtual("artistName").get(function() {
+    return this.artist ? this.artist.name : "";
+  });
+  return mongoose.models.Track || mongoose.model("Track", TrackSchema);
+};
+const musicPolicies = function initializeMusicPolicies(abacAccessControl) {
+  abacAccessControl.registerResourcePolicy("tracks", async (context) => {
+    const { user, action, currentResource, resourceModel } = context;
+    const ObjectId = abacAccessControl.db.mongoose.Types.ObjectId;
+    if (action === "read" && currentResource?.status === "published" && currentResource?.isPublic === true) {
+      return true;
+    }
+    if (action === "create") {
+      if (context.data.creator && context.data.creator.target) {
+        return context.data.creator.target.toString() === user.toString();
+      }
+      return false;
+    }
+    if (["update", "edit", "delete"].includes(action) && currentResource) {
+      if (currentResource.owner && currentResource.owner.type === "Organization") {
+        const Organization = abacAccessControl.db.organization;
+        const org = await Organization.findOne({
+          _id: currentResource.owner.target,
+          members: { $elemMatch: { user: new ObjectId(user) } }
+        });
+        if (org) return true;
+      }
+      if (currentResource.creator && currentResource.creator.target && currentResource.creator.target.toString() === user.toString()) {
+        return true;
+      }
+      return false;
+    }
+    return false;
+  });
+  abacAccessControl.registerResourcePolicy("albums", async (context) => {
+    return abacAccessControl.policies.resources.tracks(context);
+  });
+  abacAccessControl.registerResourcePolicy("playlists", async (context) => {
+    const { user, action, currentResource } = context;
+    if (currentResource && currentResource.isCollaborative && currentResource.collaborators && currentResource.collaborators.some((collaborator) => collaborator.toString() === user.toString())) {
+      if (action === "edit" || action === "update") {
+        return true;
+      }
+    }
+    return abacAccessControl.policies.resources.tracks(context);
+  });
+  abacAccessControl.registerResourcePolicy("artists", async (context) => {
+    return abacAccessControl.policies.resources.tracks(context);
+  });
+  return abacAccessControl;
+};
+const albumRoutes = function(app, db, origins, publicPath) {
+  const controller = AlbumController(app, db);
+  const { authJwt } = middlewareIndexFactory(db);
+  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);
+  app.get("/api/albums/:albumId/tracks", controller.getAlbumTracks);
+  app.get("/api/albums/featured", controller.getFeaturedAlbums);
+  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 });
+    }
+  });
+};
+const artistRoutes = function(app, db, origins, publicPath) {
+  const controller = ArtistController(app, db);
+  const { authJwt } = middlewareIndexFactory(db);
+  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);
+  app.get("/api/artists/:artistId/discography", controller.getDiscography);
+  app.put("/api/artists/:artistId/verify", [authJwt.verifyToken, authJwt.isAdmin], controller.verifyArtist);
+  app.get("/api/artists/:artistId/related", controller.getRelatedArtists);
+  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 });
+    }
+  });
+};
+const genreRoutes = function(app, db, origins, publicPath) {
+  const controller = GenreController(app, db);
+  const { authJwt } = middlewareIndexFactory(db);
+  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);
+  app.get("/api/genres/:genreId/tracks", controller.getGenreTracks);
+  app.get("/api/genres/popular", controller.getPopularGenres);
+  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 });
+    }
+  });
+};
+const { getInstance } = globalsabac;
+const musicRoutes = function(app, db, origins, publicPath) {
+  const { MusicController: MusicController$1 } = MusicController(app, db);
+  const { authJwt } = middlewareIndexFactory(db);
+  const controller = new MusicController$1("/api/tracks", app, db, db.track, {
+    disableDefaultRoutes: true
+  });
+  const abac = getInstance(db);
+  app.post(
+    "/api/tracks/create",
+    [
+      authJwt.verifyToken(),
+      // Auth middleware
+      (req, res, next) => {
+        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));
+  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" });
+      }
+      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 });
+    }
+  });
+  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 });
+    }
+  });
+  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 });
+    }
+  });
+  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 });
+    }
+  });
+};
+const playlistRoutes = function(app, db, origins, publicPath) {
+  const controller = PlaylistController(app, db);
+  const { authJwt } = middlewareIndexFactory(db);
+  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);
+  app.get("/api/playlists/user/:userId?", [authJwt.verifyToken], controller.getUserPlaylists);
+  app.post("/api/playlists/:playlistId/tracks/:trackId", [authJwt.verifyToken], controller.addTrack);
+  app.delete("/api/playlists/:playlistId/tracks/:trackId", [authJwt.verifyToken], controller.removeTrack);
+  app.post("/api/playlists/:playlistId/collaborators/:userId", [authJwt.verifyToken], controller.addCollaborator);
+  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 (!playlist.isPublic) {
+        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 });
+    }
+  });
+};
+const searchRoutes = function(app, db, origins, publicPath) {
+  const controller = SearchController(app, db);
+  app.get("/api/music/search", controller.search);
+};
+const streamRoutes = function(app, db, origins, publicPath) {
+  console.log("rouus publioc is", publicPath);
+  const controller = StreamController(app, db, publicPath);
+  app.get("/api/stream/:trackId", controller.streamAudio);
+  app.get("/api/waveform/:trackId", async (req, res) => {
+    try {
+      const track = await db.track.findById(req.params.trackId);
+      if (!track) {
+        return res.status(404).json({ error: "Track not found" });
+      }
+      const waveformPath = path.join(process.env.FILE_STORAGE_PATH || "./uploads", `waveforms/${track._id}.json`);
+      if (fs.existsSync(waveformPath)) {
+        const waveformData = JSON.parse(fs.readFileSync(waveformPath, "utf8"));
+        return res.json(waveformData);
+      }
+      res.status(404).json({ error: "Waveform data not found" });
+    } catch (error) {
+      console.error(error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+};
+const StreamingHandler = function(db) {
+  const logger = new Logger(db);
+  return {
+    // Handle WebSocket messages for music streaming
+    handleStreamingMessage: async (ws, message) => {
+      try {
+        const { action, data } = message;
+        switch (action) {
+          case "startPlaying":
+            if (ws.userId && data.trackId) {
+              await db.playHistory.create({
+                user: ws.userId,
+                track: data.trackId,
+                playedAt: /* @__PURE__ */ new Date(),
+                deviceInfo: data.deviceInfo || "Unknown",
+                playedFrom: data.from || "other",
+                contextId: data.contextId || null
+              });
+              await db.track.findByIdAndUpdate(data.trackId, { $inc: { playCount: 1 } });
+              ws.send(
+                JSON.stringify({
+                  type: "playAcknowledged",
+                  trackId: data.trackId
+                })
+              );
+            }
+            break;
+          case "syncPosition":
+            if (ws.userId && data.trackId && data.position) {
+              const latestPlay = await db.playHistory.findOne({
+                user: ws.userId,
+                track: data.trackId
+              }).sort({ playedAt: -1 });
+              if (latestPlay) {
+                latestPlay.playDuration = data.position;
+                await latestPlay.save();
+              }
+            }
+            break;
+          case "getRecommendations":
+            if (ws.userId) {
+              const recentTracks = await db.playHistory.find({
+                user: ws.userId
+              }).sort({ playedAt: -1 }).limit(10).populate("track");
+              const recentGenres = /* @__PURE__ */ new Set();
+              const recentArtists = /* @__PURE__ */ new Set();
+              recentTracks.forEach((history) => {
+                if (history.track) {
+                  if (history.track.genre) {
+                    history.track.genre.forEach((g) => recentGenres.add(g.toString()));
+                  }
+                  if (history.track.artist) {
+                    recentArtists.add(history.track.artist.toString());
+                  }
+                }
+              });
+              const recommendations = await db.track.find({
+                $or: [{ genre: { $in: Array.from(recentGenres) } }, { artist: { $in: Array.from(recentArtists) } }],
+                _id: { $nin: recentTracks.map((h) => h.track._id) },
+                // Exclude recently played
+                status: "published",
+                isPublic: true
+              }).limit(10).populate("artist", "name").populate("album", "title coverUrl");
+              ws.send(
+                JSON.stringify({
+                  type: "recommendations",
+                  tracks: recommendations
+                })
+              );
+            }
+            break;
+          case "joinListeningParty":
+            if (ws.userId && data.partyId) {
+              ws.listeningParty = data.partyId;
+              global.webSocketManager.broadcastToModuleWithFilter("music-streaming", (socket) => socket.listeningParty === data.partyId, {
+                type: "partyMemberJoined",
+                userId: ws.userId,
+                partyId: data.partyId
+              });
+            }
+            break;
+          case "syncPartyPlayback":
+            if (ws.userId && ws.listeningParty && data.trackId && data.position) {
+              global.webSocketManager.broadcastToModuleWithFilter("music-streaming", (socket) => socket.listeningParty === ws.listeningParty && socket !== ws, {
+                type: "partyPlaybackSync",
+                trackId: data.trackId,
+                position: data.position,
+                isPlaying: data.isPlaying,
+                timestamp: Date.now()
+              });
+            }
+            break;
+          default:
+            logger.info(`Unknown streaming action: ${action}`);
+        }
+      } catch (error) {
+        logger.error(`Error in streaming handler: ${error.message}`);
+        ws.send(
+          JSON.stringify({
+            type: "error",
+            message: "An error occurred while processing your request"
+          })
+        );
+      }
+    }
+  };
+};
+function initializeMusic({ app, db, wss, origins, publicPath }) {
+  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);
+  if (app) {
+    musicRoutes(app, db);
+    playlistRoutes(app, db);
+    albumRoutes(app, db);
+    artistRoutes(app, db);
+    streamRoutes(app, db, origins, publicPath);
+    searchRoutes(app, db);
+    genreRoutes(app, db);
+  }
+  const { getInstance: getInstance2 } = globalsabac;
+  const abac = getInstance2(db);
+  musicPolicies(abac);
+  const { WebSocketManager: WebSocketManager$1 } = WebSocketManager;
+  if (global.webSocketManager && global.webSocketManager instanceof WebSocketManager$1) {
+    global.webSocketManager.registerModule("music-streaming", StreamingHandler(db).handleStreamingMessage);
+  }
+  new Cache({ ttlSeconds: 60 * 15 });
+  const musicLogger = new Logger(db);
+  musicLogger.info("Music module initialized");
+}
+const models = {
+  TrackModel,
+  PlaylistModel,
+  AlbumModel,
+  ArtistModel,
+  GenreModel,
+  PlayHistoryModel
+};
+const routes = {
+  musicRoutes,
+  playlistRoutes,
+  albumRoutes,
+  artistRoutes,
+  streamRoutes,
+  searchRoutes,
+  genreRoutes
+};
+const controllers = {
+  MusicController,
+  PlaylistController,
+  AlbumController,
+  ArtistController,
+  StreamController,
+  SearchController,
+  GenreController
+};
+const music_server = {
+  initialize: initializeMusic,
+  models,
+  routes,
+  controllers
+};
+export {
+  controllers,
+  music_server as default,
+  initializeMusic as initialize,
+  models,
+  routes
+};