@ozdao/martyrs 0.2.486 → 0.2.487

package/src/modules/music/middlewares/tracks.verifier.js

@@ -0,0 +1,263 @@
+// @martyrs/src/modules/music/middlewares/tracks.verifier.js
+import Validator from '@martyrs/src/modules/globals/controllers/classes/globals.validator.js';
+import Verifier from '@martyrs/src/modules/globals/controllers/classes/globals.verifier.js';
+
+export default function(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(10000, '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(10000, '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
+  };
+}

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

@@ -1,6 +1,7 @@
 // Store modules
 import * as storeAlbums from './store/albums.js';
 import * as storeArtists from './store/artists.js';
+import * as storeGenres from './store/genres.js';
 import * as storePlayer from './store/player.js';
 import * as storePlaylists from './store/playlists.js';
 import * as storeSearch from './store/search.js';
@@ -13,14 +14,14 @@ import routerMusic from './router/music.js';
 import MusicLayout from './components/layouts/MusicLayout.vue';
 
 // Pages
-import AlbumDetail from './components/pages/AlbumDetail.vue';
-import ArtistDetail from './components/pages/ArtistDetail.vue';
+import Album from './components/pages/Album.vue';
+import Artist from './components/pages/Artist.vue';
 import MusicHome from './components/pages/MusicHome.vue';
 import MusicLibrary from './components/pages/MusicLibrary.vue';
-import MusicUpload from './components/pages/MusicUpload.vue';
-import PlaylistDetail from './components/pages/PlaylistDetail.vue';
+import TrackCreate from './components/pages/TrackCreate.vue';
+import Playlist from './components/pages/Playlist.vue';
 import SearchResults from './components/pages/SearchResults.vue';
-import TrackDetail from './components/pages/TrackDetail.vue';
+import Track from './components/pages/Track.vue';
 
 // Components - Player
 import MusicPlayer from './components/player/MusicPlayer.vue';
@@ -32,17 +33,15 @@ import AlbumCard from './components/cards/AlbumCard.vue';
 import ArtistCard from './components/cards/ArtistCard.vue';
 import PlaylistCard from './components/cards/PlaylistCard.vue';
 import TrackCard from './components/cards/TrackCard.vue';
+import TrackListCard from './components/cards/TrackListCard.vue';
 
-// Components - Lists
-import AlbumList from './components/lists/AlbumList.vue';
-import ArtistList from './components/lists/ArtistList.vue';
-import PlaylistList from './components/lists/PlaylistList.vue';
-import TrackList from './components/lists/TrackList.vue';
 
 // Components - Forms
+import ArtistForm from './components/forms/ArtistForm.vue';
+import AlbumForm from './components/forms/AlbumForm.vue';
 import PlaylistForm from './components/forms/PlaylistForm.vue';
 import SearchForm from './components/forms/SearchForm.vue';
-import UploadForm from './components/forms/UploadForm.vue';
+import TrackForm from './components/forms/TrackForm.vue';
 
 // WebSocket integration for streaming
 import globalWebSocket from '@martyrs/src/modules/globals/views/classes/globals.websocket.js';
@@ -66,6 +65,7 @@ function initializeMusic(app, store, router, config, options = {}) {
   store.addStore('playlists', storePlaylists);
   store.addStore('albums', storeAlbums);
   store.addStore('artists', storeArtists);
+  store.addStore('genres', storeGenres);
   store.addStore('player', storePlayer);
   store.addStore('search', storeSearch);
 
@@ -103,6 +103,7 @@ const ModuleMusic = {
       storePlaylists,
       storeAlbums,
       storeArtists,
+      storeGenres,
       storePlayer,
       storeSearch,
     },
@@ -115,30 +116,28 @@ const ModuleMusic = {
       // Pages
       MusicHome,
       SearchResults,
-      ArtistDetail,
-      AlbumDetail,
-      PlaylistDetail,
-      TrackDetail,
+      Artist,
+      Album,
+      Playlist,
+      Track,
       MusicLibrary,
-      MusicUpload,
+      TrackCreate,
       // Player Components
       MusicPlayer,
       TrackProgress,
       VolumeControl,
       // Cards
       TrackCard,
+      TrackListCard,
       AlbumCard,
       PlaylistCard,
       ArtistCard,
-      // Lists
-      TrackList,
-      AlbumList,
-      PlaylistList,
-      ArtistList,
       // Forms
+      ArtistForm,
+      AlbumForm,
       PlaylistForm,
       SearchForm,
-      UploadForm,
+      TrackForm,
     },
   },
 };
@@ -146,11 +145,9 @@ const ModuleMusic = {
 // Named exports for direct component imports
 export {
   AlbumCard,
-  AlbumDetail,
-  AlbumList,
+  Album,
   ArtistCard,
-  ArtistDetail,
-  ArtistList,
+  Artist,
   // Pages
   MusicHome,
   // Layout
@@ -158,26 +155,27 @@ export {
   MusicLibrary,
   // Player Components
   MusicPlayer,
-  MusicUpload,
+  TrackCreate,
   PlaylistCard,
-  PlaylistDetail,
+  Playlist,
   // Forms
+  ArtistForm,
+  AlbumForm,
   PlaylistForm,
-  PlaylistList,
   SearchForm,
   SearchResults,
   // Cards
   TrackCard,
-  TrackDetail,
-  // Lists
-  TrackList,
+  TrackListCard,
+  Track,
+  TrackForm,
   TrackProgress,
-  UploadForm,
   VolumeControl,
   // Router
   routerMusic,
   storeAlbums,
   storeArtists,
+  storeGenres,
   storePlayer,
   storePlaylists,
   storeSearch,

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

@@ -2,27 +2,33 @@ import globalsabac from '@martyrs/src/modules/globals/controllers/classes/global
 import Cache from '@martyrs/src/modules/globals/controllers/classes/globals.cache.js';
 import Logger from '@martyrs/src/modules/globals/controllers/classes/globals.logger.js';
 import globalswebsocket from '@martyrs/src/modules/globals/controllers/classes/globals.websocket.js';
-import AlbumController from './controllers/album.controller.js';
-import ArtistController from './controllers/artist.controller.js';
-import GenreController from './controllers/genre.controller.js';
-import MusicController from './controllers/music.controller.js';
-import PlaylistController from './controllers/playlist.controller.js';
+
+// NEW CRUD Routes
+import setupTracksRoutes from './routes/tracks.routes.js';
+import setupArtistsRoutes from './routes/artists.routes.js';
+import setupAlbumsRoutes from './routes/albums.routes.js';
+import setupPlaylistsRoutes from './routes/playlists.routes.js';
+import setupGenresRoutes from './routes/genres.routes.js';
+
+// Keep only necessary controllers (search, stream)
 import SearchController from './controllers/search.controller.js';
 import StreamController from './controllers/stream.controller.js';
+
+// Models
 import AlbumModel from './models/album.model.js';
 import ArtistModel from './models/artist.model.js';
 import GenreModel from './models/genre.model.js';
 import PlayHistoryModel from './models/play-history.model.js';
 import PlaylistModel from './models/playlist.model.js';
 import TrackModel from './models/track.model.js';
+
+// Policies
 import musicPolicies from './policies/music.policies.js';
-import albumRoutes from './routes/album.routes.js';
-import artistRoutes from './routes/artist.routes.js';
-import genreRoutes from './routes/genre.routes.js';
-import musicRoutes from './routes/music.routes.js';
-import playlistRoutes from './routes/playlist.routes.js';
+
+// Keep legacy routes for now (search, stream)
 import searchRoutes from './routes/search.routes.js';
 import streamRoutes from './routes/stream.routes.js';
+
 import StreamingHandler from './websocket/streaming.handler.js';
 /**
  * Initialize the Music module
@@ -40,15 +46,18 @@ function initializeMusic({ app, db, wss, origins, publicPath }) {
   db.genre = GenreModel(db);
   db.playHistory = PlayHistoryModel(db);
   console.log('server publioc is', publicPath);
-  // Set up routes if app is provided
+  // Set up NEW CRUD routes if app is provided
   if (app) {
-    musicRoutes(app, db, origins, publicPath);
-    playlistRoutes(app, db, origins, publicPath);
-    albumRoutes(app, db, origins, publicPath);
-    artistRoutes(app, db, origins, publicPath);
+    // Initialize new CRUD routes
+    setupTracksRoutes(app, db);
+    setupArtistsRoutes(app, db);
+    setupAlbumsRoutes(app, db);
+    setupPlaylistsRoutes(app, db);
+    setupGenresRoutes(app, db);
+    
+    // Keep legacy routes that don't have CRUD equivalents
     streamRoutes(app, db, origins, publicPath);
     searchRoutes(app, db, origins, publicPath);
-    genreRoutes(app, db, origins, publicPath);
   }
   // Initialize ABAC policies for music module
   const { getInstance } = globalsabac;
@@ -73,22 +82,20 @@ export const models = {
   PlayHistoryModel,
 };
 export const routes = {
-  musicRoutes,
-  playlistRoutes,
-  albumRoutes,
-  artistRoutes,
+  // NEW CRUD Routes
+  setupTracksRoutes,
+  setupArtistsRoutes,
+  setupAlbumsRoutes,
+  setupPlaylistsRoutes,
+  setupGenresRoutes,
+  // Legacy routes
   streamRoutes,
   searchRoutes,
-  genreRoutes,
 };
 export const controllers = {
-  MusicController,
-  PlaylistController,
-  AlbumController,
-  ArtistController,
+  // Keep only non-CRUD controllers
   StreamController,
   SearchController,
-  GenreController,
 };
 export { initializeMusic as initialize };
 export default {

package/src/modules/music/router/albums.js

@@ -0,0 +1,31 @@
+// router/albums.js
+export default [
+  {
+    path: 'albums/create',
+    name: 'album-create',
+    component: () => import('../components/pages/AlbumCreate.vue'),
+    meta: {
+      title: 'Create Album',
+      requiresAuth: true,
+    },
+  },
+  {
+    path: 'albums/:url/edit',
+    name: 'album-edit',
+    component: () => import('../components/pages/AlbumEdit.vue'),
+    props: true,
+    meta: {
+      title: 'Edit Album',
+      requiresAuth: true,
+    },
+  },
+  {
+    path: 'albums/:url',
+    name: 'album',
+    component: () => import('../components/pages/Album.vue'),
+    props: true,
+    meta: {
+      title: 'Album',
+    },
+  },
+];

package/src/modules/music/router/artists.js

@@ -0,0 +1,31 @@
+// router/artists.js
+export default [
+  {
+    path: 'artists/create',
+    name: 'artist-create',
+    component: () => import('../components/pages/ArtistCreate.vue'),
+    meta: {
+      title: 'Create Artist',
+      requiresAuth: true,
+    },
+  },
+  {
+    path: 'artists/:url/edit',
+    name: 'artist-edit',
+    component: () => import('../components/pages/ArtistEdit.vue'),
+    props: true,
+    meta: {
+      title: 'Edit Artist',
+      requiresAuth: true,
+    },
+  },
+  {
+    path: 'artists/:url',
+    name: 'artist',
+    component: () => import('../components/pages/Artist.vue'),
+    props: true,
+    meta: {
+      title: 'Artist',
+    },
+  },
+];

package/src/modules/music/router/music.js

@@ -1,4 +1,9 @@
 // router/music.js
+import artistRoutes from './artists.js';
+import albumRoutes from './albums.js';
+import trackRoutes from './tracks.js';
+import playlistRoutes from './playlists.js';
+
 export default {
   path: 'music',
   component: () => import('../components/layouts/MusicLayout.vue'),
@@ -28,69 +33,13 @@ export default {
         requiresAuth: true,
       },
     },
-    {
-      path: 'upload',
-      name: 'music-upload',
-      component: () => import('../components/pages/MusicUpload.vue'),
-      meta: {
-        title: 'Upload Music',
-        requiresAuth: true,
-      },
-    },
-    {
-      path: 'artists/:url',
-      name: 'artist-detail',
-      component: () => import('../components/pages/ArtistDetail.vue'),
-      props: true,
-      meta: {
-        title: 'Artist Details',
-      },
-    },
-    {
-      path: 'artists/create',
-      name: 'artist-create',
-      component: () => import('../components/pages/ArtistForm.vue'),
-      meta: {
-        title: 'Create Artist',
-        requiresAuth: true,
-      },
-    },
-    {
-      path: 'artists/:id/edit',
-      name: 'artist-edit',
-      component: () => import('../components/pages/ArtistForm.vue'),
-      props: route => ({ isEditMode: true, artistId: route.params.id }),
-      meta: {
-        title: 'Edit Artist',
-        requiresAuth: true,
-      },
-    },
-    {
-      path: 'albums/:url',
-      name: 'album-detail',
-      component: () => import('../components/pages/AlbumDetail.vue'),
-      props: true,
-      meta: {
-        title: 'Album Details',
-      },
-    },
-    {
-      path: 'playlists/:url',
-      name: 'playlist-detail',
-      component: () => import('../components/pages/PlaylistDetail.vue'),
-      props: true,
-      meta: {
-        title: 'Playlist Details',
-      },
-    },
-    {
-      path: 'tracks/:url',
-      name: 'track-detail',
-      component: () => import('../components/pages/TrackDetail.vue'),
-      props: true,
-      meta: {
-        title: 'Track Details',
-      },
-    },
+    // Artists routes
+    ...artistRoutes,
+    // Albums routes
+    ...albumRoutes,
+    // Tracks routes
+    ...trackRoutes,
+    // Playlists routes
+    ...playlistRoutes,
   ],
-};
+};

package/src/modules/music/router/playlists.js

@@ -0,0 +1,31 @@
+// router/playlists.js
+export default [
+  {
+    path: 'playlists/create',
+    name: 'playlist-create',
+    component: () => import('../components/pages/PlaylistCreate.vue'),
+    meta: {
+      title: 'Create Playlist',
+      requiresAuth: true,
+    },
+  },
+  {
+    path: 'playlists/:url/edit',
+    name: 'playlist-edit',
+    component: () => import('../components/pages/PlaylistEdit.vue'),
+    props: true,
+    meta: {
+      title: 'Edit Playlist',
+      requiresAuth: true,
+    },
+  },
+  {
+    path: 'playlists/:url',
+    name: 'playlist',
+    component: () => import('../components/pages/Playlist.vue'),
+    props: true,
+    meta: {
+      title: 'Playlist',
+    },
+  },
+];