@ozdao/martyrs 0.2.488 → 0.2.491

package/dist/music.server.js

@@ -0,0 +1,2021 @@
+import { g as globalsabac } from "./globals.abac-DNdtSYop.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 "./crud-Cwx5VlSm.js";
+import { A as ABAC } from "./abac-Cf_9lCSh.js";
+import { V as Verifier, a as Validator } from "./globals.verifier-CWFz5Gh2.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-BqH4v5vH.js";
+import { a as applySocialsSchema } from "./socials.schema-BOZV82Mp.js";
+function tracksVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    title: {
+      rule: "required",
+      validator: Validator.schema().string().required("Track title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+    },
+    artist: {
+      rule: "required",
+      validator: Validator.schema().string().required("Artist is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+    },
+    album: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+    },
+    fileUrl: {
+      rule: "required",
+      validator: Validator.schema().string().required("File URL is required").pattern(/^https?:\/\/.+/, "Invalid file URL format")
+    },
+    coverUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid cover URL format")
+    },
+    duration: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().number().min(0, "Duration cannot be negative").max(3600, "Duration cannot exceed 1 hour")
+    },
+    genre: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      )
+    },
+    releaseDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    isExplicit: {
+      rule: "optional",
+      default: false,
+      validator: Validator.schema().boolean()
+    },
+    lyrics: {
+      rule: "optional",
+      validator: Validator.schema().string().max(1e4, "Lyrics too long")
+    },
+    isPublic: {
+      rule: "optional",
+      default: true,
+      validator: Validator.schema().boolean()
+    },
+    owner: {
+      rule: "required",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["user", "organization"]),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      })
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Track ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
+    },
+    title: {
+      rule: "optional",
+      validator: Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+    },
+    artist: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+    },
+    album: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+    },
+    fileUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid file URL format")
+    },
+    coverUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid cover URL format")
+    },
+    duration: {
+      rule: "optional",
+      validator: Validator.schema().number().min(0, "Duration cannot be negative").max(3600, "Duration cannot exceed 1 hour")
+    },
+    genre: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      )
+    },
+    releaseDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    isExplicit: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    },
+    lyrics: {
+      rule: "optional",
+      validator: Validator.schema().string().max(1e4, "Lyrics too long")
+    },
+    isPublic: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
+    },
+    artist: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+    },
+    album: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+    },
+    genre: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+    },
+    isPublic: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "published", "archived"])
+    },
+    skip: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().integer().min(0)
+    },
+    limit: {
+      rule: "optional",
+      default: 20,
+      validator: Validator.schema().integer().min(1).max(100)
+    },
+    sortParam: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["title", "playCount", "releaseDate", "createdAt", "updatedAt"])
+    },
+    sortOrder: {
+      rule: "optional",
+      default: "desc",
+      validator: Validator.schema().string().oneOf(["asc", "desc"])
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Track ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance: getInstance$4 } = ABAC;
+function setupTracksRoutes(app, db) {
+  const abac = getInstance$4(db);
+  const verifier = tracksVerifierFactory();
+  const tracksCRUD = new CRUD({
+    app,
+    db,
+    model: db.track,
+    modelName: "track",
+    basePath: "/api/tracks",
+    auth: true,
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ["tracks", "music"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  tracksCRUD.addAction("get-by-url", {
+    method: "get",
+    path: "/url/:url",
+    auth: false,
+    handler: 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 });
+      }
+    }
+  });
+  tracksCRUD.addAction("recent", {
+    method: "get",
+    path: "/recent",
+    auth: false,
+    handler: 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 });
+      }
+    }
+  });
+  tracksCRUD.addAction("popular", {
+    method: "get",
+    path: "/popular",
+    auth: false,
+    handler: 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 });
+      }
+    }
+  });
+  tracksCRUD.addAction("by-genre", {
+    method: "get",
+    path: "/genre/:genreId",
+    auth: false,
+    handler: 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 });
+      }
+    }
+  });
+  return tracksCRUD;
+}
+function artistsVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    name: {
+      rule: "required",
+      validator: Validator.schema().string().required("Artist name is required").min(1, "Name cannot be empty").max(100, "Name must not exceed 100 characters")
+    },
+    bio: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Bio must not exceed 2000 characters")
+    },
+    photoUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+    },
+    coverUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+    },
+    genre: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      )
+    },
+    website: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid website URL format")
+    },
+    location: {
+      rule: "optional",
+      validator: Validator.schema().string().max(100, "Location must not exceed 100 characters")
+    },
+    owner: {
+      rule: "required",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["user", "organization"]),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      })
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Artist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+    },
+    name: {
+      rule: "optional",
+      validator: Validator.schema().string().min(1, "Name cannot be empty").max(100, "Name must not exceed 100 characters")
+    },
+    bio: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Bio must not exceed 2000 characters")
+    },
+    photoUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid photo URL format")
+    },
+    coverUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid cover URL format")
+    },
+    genre: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      )
+    },
+    website: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid website URL format")
+    },
+    location: {
+      rule: "optional",
+      validator: Validator.schema().string().max(100, "Location must not exceed 100 characters")
+    },
+    isVerified: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+    },
+    genre: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+    },
+    isVerified: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "published", "archived"])
+    },
+    location: {
+      rule: "optional",
+      validator: Validator.schema().string()
+    },
+    skip: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().integer().min(0)
+    },
+    limit: {
+      rule: "optional",
+      default: 20,
+      validator: Validator.schema().integer().min(1).max(100)
+    },
+    sortParam: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["name", "popularity", "createdAt", "updatedAt"])
+    },
+    sortOrder: {
+      rule: "optional",
+      default: "desc",
+      validator: Validator.schema().string().oneOf(["asc", "desc"])
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Artist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance: getInstance$3 } = ABAC;
+function setupArtistsRoutes(app, db) {
+  const abac = getInstance$3(db);
+  const verifier = artistsVerifierFactory();
+  const artistsCRUD = new CRUD({
+    app,
+    db,
+    model: db.artist,
+    modelName: "artist",
+    basePath: "/api/artists",
+    auth: true,
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ["artists", "music"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  artistsCRUD.addAction("get-by-url", {
+    method: "get",
+    path: "/url/:url",
+    auth: false,
+    handler: 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 });
+      }
+    }
+  });
+  artistsCRUD.addAction("discography", {
+    method: "get",
+    path: "/:artistId/discography",
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const { artistId } = req.params;
+        const albums = await db.album.find({ artists: artistId }).populate("artists", "name").sort({ releaseDate: -1 });
+        const tracks = await db.track.find({
+          artist: artistId,
+          status: "published",
+          isPublic: true
+        }).populate("album", "title").sort({ releaseDate: -1 });
+        res.json({
+          albums,
+          tracks,
+          artist: artistId
+        });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  artistsCRUD.addAction("verify-artist", {
+    method: "put",
+    path: "/:artistId/verify",
+    auth: true,
+    abac: {
+      resource: "artists",
+      action: "verify",
+      strict: true
+    },
+    handler: async (req, res) => {
+      try {
+        const { artistId } = req.params;
+        const artist = await db.artist.findByIdAndUpdate(
+          artistId,
+          { isVerified: true },
+          { new: true }
+        );
+        if (!artist) {
+          return res.status(404).json({ error: "Artist not found" });
+        }
+        res.json({
+          message: "Artist verified successfully",
+          artist
+        });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  artistsCRUD.addAction("related-artists", {
+    method: "get",
+    path: "/:artistId/related",
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const { artistId } = req.params;
+        const limit = parseInt(req.query.limit) || 10;
+        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(limit).sort({ popularity: -1 });
+        res.json(relatedArtists);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  return artistsCRUD;
+}
+function albumsVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    title: {
+      rule: "required",
+      validator: Validator.schema().string().required("Album title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+    },
+    releaseDate: {
+      rule: "required",
+      validator: Validator.schema().date().required("Release date is required")
+    },
+    coverArt: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid cover art URL format")
+    },
+    artists: {
+      rule: "required",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      ).min(1, "At least one artist is required")
+    },
+    type: {
+      rule: "optional",
+      default: "album",
+      validator: Validator.schema().string().oneOf(["album", "single", "EP", "compilation"], "Invalid album type")
+    },
+    genres: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      )
+    },
+    totalTracks: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().integer().min(0, "Total tracks cannot be negative").max(100, "Too many tracks")
+    },
+    owner: {
+      rule: "required",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["user", "organization"]),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      })
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Album ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+    },
+    title: {
+      rule: "optional",
+      validator: Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+    },
+    releaseDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    coverArt: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid cover art URL format")
+    },
+    artists: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      ).min(1, "At least one artist is required")
+    },
+    type: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["album", "single", "EP", "compilation"], "Invalid album type")
+    },
+    genres: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      )
+    },
+    totalTracks: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(0, "Total tracks cannot be negative").max(100, "Too many tracks")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+    },
+    artists: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+    },
+    type: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["album", "single", "EP", "compilation"])
+    },
+    genres: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "published", "archived"])
+    },
+    skip: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().integer().min(0)
+    },
+    limit: {
+      rule: "optional",
+      default: 20,
+      validator: Validator.schema().integer().min(1).max(100)
+    },
+    sortParam: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["title", "releaseDate", "totalTracks", "createdAt", "updatedAt"])
+    },
+    sortOrder: {
+      rule: "optional",
+      default: "desc",
+      validator: Validator.schema().string().oneOf(["asc", "desc"])
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Album ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance: getInstance$2 } = ABAC;
+function setupAlbumsRoutes(app, db) {
+  const abac = getInstance$2(db);
+  const verifier = albumsVerifierFactory();
+  const albumsCRUD = new CRUD({
+    app,
+    db,
+    model: db.album,
+    modelName: "album",
+    basePath: "/api/albums",
+    auth: true,
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ["albums", "music"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  albumsCRUD.addAction("get-by-url", {
+    method: "get",
+    path: "/url/:url",
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const album = await db.album.findOne({ url: req.params.url }).populate("artists", "name url");
+        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 });
+      }
+    }
+  });
+  albumsCRUD.addAction("album-tracks", {
+    method: "get",
+    path: "/:albumId/tracks",
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const { albumId } = req.params;
+        const tracks = await db.track.find({
+          album: albumId,
+          status: "published",
+          isPublic: true
+        }).populate("artist", "name url").populate("genre", "name").sort({ trackNumber: 1, createdAt: 1 });
+        res.json(tracks);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  albumsCRUD.addAction("featured", {
+    method: "get",
+    path: "/featured",
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const limit = parseInt(req.query.limit) || 10;
+        const featuredAlbums = await db.album.find({
+          status: "published",
+          releaseDate: {
+            $gte: new Date(Date.now() - 90 * 24 * 60 * 60 * 1e3)
+            // последние 90 дней
+          }
+        }).populate("artists", "name url").sort({ createdAt: -1 }).limit(limit);
+        res.json(featuredAlbums);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  return albumsCRUD;
+}
+function playlistsVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    title: {
+      rule: "required",
+      validator: Validator.schema().string().required("Playlist title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+    },
+    coverUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid cover URL format")
+    },
+    tracks: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().object({
+          track: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format").required(),
+          addedAt: Validator.schema().date()
+        })
+      )
+    },
+    isPublic: {
+      rule: "optional",
+      default: true,
+      validator: Validator.schema().boolean()
+    },
+    isCollaborative: {
+      rule: "optional",
+      default: false,
+      validator: Validator.schema().boolean()
+    },
+    collaborators: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid collaborator ID format")
+      )
+    },
+    owner: {
+      rule: "required",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["user", "organization"]),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      })
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Playlist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
+    },
+    title: {
+      rule: "optional",
+      validator: Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+    },
+    coverUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid cover URL format")
+    },
+    tracks: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().object({
+          track: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format").required(),
+          addedAt: Validator.schema().date()
+        })
+      )
+    },
+    isPublic: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    },
+    isCollaborative: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    },
+    collaborators: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid collaborator ID format")
+      )
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
+    },
+    owner: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid owner ID format")
+    },
+    isPublic: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    },
+    isCollaborative: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "published", "archived"])
+    },
+    skip: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().integer().min(0)
+    },
+    limit: {
+      rule: "optional",
+      default: 20,
+      validator: Validator.schema().integer().min(1).max(100)
+    },
+    sortParam: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["title", "followers", "createdAt", "updatedAt"])
+    },
+    sortOrder: {
+      rule: "optional",
+      default: "desc",
+      validator: Validator.schema().string().oneOf(["asc", "desc"])
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Playlist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance: getInstance$1 } = ABAC;
+function setupPlaylistsRoutes(app, db) {
+  const abac = getInstance$1(db);
+  const verifier = playlistsVerifierFactory();
+  const playlistsCRUD = new CRUD({
+    app,
+    db,
+    model: db.playlist,
+    modelName: "playlist",
+    basePath: "/api/playlists",
+    auth: true,
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ["playlists", "music"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  playlistsCRUD.addAction("get-by-url", {
+    method: "get",
+    path: "/url/:url",
+    auth: false,
+    handler: 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 });
+      }
+    }
+  });
+  playlistsCRUD.addAction("user-playlists", {
+    method: "get",
+    path: "/user/:userId?",
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const userId = req.params.userId || req.userId;
+        const query = { "owner.target": userId };
+        if (userId !== req.userId) {
+          query.isPublic = true;
+        }
+        const playlists = await db.playlist.find(query).populate("tracks.track", "title artist").sort({ updatedAt: -1 });
+        res.json(playlists);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  playlistsCRUD.addAction("add-track", {
+    method: "post",
+    path: "/:playlistId/tracks/:trackId",
+    auth: true,
+    abac: {
+      resource: "playlists",
+      action: "update"
+    },
+    handler: async (req, res) => {
+      try {
+        const { playlistId, trackId } = req.params;
+        const track = await db.track.findById(trackId);
+        if (!track) {
+          return res.status(404).json({ error: "Track not found" });
+        }
+        const playlist = await db.playlist.findById(playlistId);
+        if (!playlist) {
+          return res.status(404).json({ error: "Playlist not found" });
+        }
+        const trackExists = playlist.tracks.some((t) => t.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();
+        res.json({
+          message: "Track added to playlist successfully",
+          playlist
+        });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  playlistsCRUD.addAction("remove-track", {
+    method: "delete",
+    path: "/:playlistId/tracks/:trackId",
+    auth: true,
+    abac: {
+      resource: "playlists",
+      action: "update"
+    },
+    handler: async (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" });
+        }
+        playlist.tracks = playlist.tracks.filter(
+          (t) => t.track.toString() !== trackId
+        );
+        await playlist.save();
+        res.json({
+          message: "Track removed from playlist successfully",
+          playlist
+        });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  playlistsCRUD.addAction("add-collaborator", {
+    method: "post",
+    path: "/:playlistId/collaborators/:userId",
+    auth: true,
+    abac: {
+      resource: "playlists",
+      action: "update"
+    },
+    handler: async (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.collaborators.includes(userId)) {
+          return res.status(400).json({ error: "User is already a collaborator" });
+        }
+        playlist.collaborators.push(userId);
+        playlist.isCollaborative = true;
+        await playlist.save();
+        res.json({
+          message: "Collaborator added successfully",
+          playlist
+        });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  return playlistsCRUD;
+}
+function genresVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    name: {
+      rule: "required",
+      validator: Validator.schema().string().required("Genre name is required").min(1, "Name cannot be empty").max(50, "Name must not exceed 50 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(500, "Description must not exceed 500 characters")
+    },
+    iconUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid icon URL format")
+    },
+    popularity: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().number().min(0, "Popularity cannot be negative").max(100, "Popularity cannot exceed 100")
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Genre ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+    },
+    name: {
+      rule: "optional",
+      validator: Validator.schema().string().min(1, "Name cannot be empty").max(50, "Name must not exceed 50 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(500, "Description must not exceed 500 characters")
+    },
+    iconUrl: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid icon URL format")
+    },
+    popularity: {
+      rule: "optional",
+      validator: Validator.schema().number().min(0, "Popularity cannot be negative").max(100, "Popularity cannot exceed 100")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+    },
+    name: {
+      rule: "optional",
+      validator: Validator.schema().string()
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "published", "archived"])
+    },
+    skip: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().integer().min(0)
+    },
+    limit: {
+      rule: "optional",
+      default: 20,
+      validator: Validator.schema().integer().min(1).max(100)
+    },
+    sortParam: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["name", "popularity", "createdAt", "updatedAt"])
+    },
+    sortOrder: {
+      rule: "optional",
+      default: "desc",
+      validator: Validator.schema().string().oneOf(["asc", "desc"])
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Genre ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance } = ABAC;
+function setupGenresRoutes(app, db) {
+  const abac = getInstance(db);
+  const verifier = genresVerifierFactory();
+  const genresCRUD = new CRUD({
+    app,
+    db,
+    model: db.genre,
+    modelName: "genre",
+    basePath: "/api/genres",
+    auth: true,
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ["genres", "music"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  genresCRUD.addAction("get-by-url", {
+    method: "get",
+    path: "/url/:url",
+    auth: false,
+    handler: 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 });
+      }
+    }
+  });
+  genresCRUD.addAction("genre-tracks", {
+    method: "get",
+    path: "/:genreId/tracks",
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const { genreId } = req.params;
+        const limit = parseInt(req.query.limit) || 50;
+        const skip = parseInt(req.query.skip) || 0;
+        const tracks = await db.track.find({
+          genre: genreId,
+          status: "published",
+          isPublic: true
+        }).populate("artist", "name url").populate("album", "title url").sort({ playCount: -1, releaseDate: -1 }).skip(skip).limit(limit);
+        res.json(tracks);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  genresCRUD.addAction("popular", {
+    method: "get",
+    path: "/popular",
+    auth: false,
+    handler: async (req, res) => {
+      try {
+        const limit = parseInt(req.query.limit) || 20;
+        const popularGenres = await db.genre.find({ status: "published" }).sort({ popularity: -1 }).limit(limit);
+        res.json(popularGenres);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  return genresCRUD;
+}
+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 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) {
+    setupTracksRoutes(app, db);
+    setupArtistsRoutes(app, db);
+    setupAlbumsRoutes(app, db);
+    setupPlaylistsRoutes(app, db);
+    setupGenresRoutes(app, db);
+    streamRoutes(app, db, origins, publicPath);
+    searchRoutes(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 = {
+  // NEW CRUD Routes
+  setupTracksRoutes,
+  setupArtistsRoutes,
+  setupAlbumsRoutes,
+  setupPlaylistsRoutes,
+  setupGenresRoutes,
+  // Legacy routes
+  streamRoutes,
+  searchRoutes
+};
+const controllers = {
+  // Keep only non-CRUD controllers
+  StreamController,
+  SearchController
+};
+const music_server = {
+  initialize: initializeMusic,
+  models,
+  routes,
+  controllers
+};
+export {
+  controllers,
+  music_server as default,
+  initializeMusic as initialize,
+  models,
+  routes
+};