musora-content-services 2.107.3 → 2.107.4

package/src/services/reporting/reporting.ts

@@ -11,6 +11,10 @@ import { HttpClient } from '../../infrastructure/http/HttpClient'
 import { globalConfig } from '../config.js'
 import { ReportResponse, ReportableType, IssueTypeMap, ReportIssueOption } from './types'
 import { Brands } from '../../lib/brands'
+import { generateContentUrl, generatePlaylistUrl, generateForumPostUrl, generateCommentUrl } from '../urlBuilder.ts'
+import {fetchByRailContentId} from "../../index";
+import {fetchByRailContentIds} from "../sanity";
+import {addContextToContent} from "../contentAggregator";
 
 /**
  * Parameters for submitting a report with type-safe issue values
@@ -26,6 +30,14 @@ export type ReportParams<T extends ReportableType = ReportableType> = {
   details?: string
   /** Brand context (required: drumeo, pianote, guitareo, singeo, playbass) */
   brand: Brands | string
+  /** Full URL to the reported content (generated via urlBuilder) */
+  contentUrl?: string
+  /** Content data for URL generation (only needed if contentUrl not provided) */
+  content?: {
+    id: number
+    type: string
+    parentId?: number
+  }
 }
 
 /**
@@ -86,12 +98,68 @@ export async function report<T extends ReportableType>(
     requestBody.details = params.details
   }
 
-  const response = await httpClient.post<ReportResponse>(
+  // Generate content_url for reports (relative URL - backend adds domain)
+  if (params.type === 'content') {
+    // Fetch content and add navigateTo for courses/packs/etc
+    const contents = await addContextToContent(
+      fetchByRailContentIds,
+      [params.id],
+      { addNavigateTo: true }
+    )
+    const content = contents?.[0]
+
+    if (content) {
+      requestBody.content_url = generateContentUrl({
+        id: content.id,
+        type: content.type,
+        parentId: content.parentId || content.parent_id,
+        brand: content.brand,
+        navigateTo: content.navigateTo
+      })
+    }
+  } else if (params.type === 'playlist') {
+    requestBody.content_url = generatePlaylistUrl({
+      id: params.id
+    })
+  } else if (params.type === 'forum_post') {
+    const { fetchPost } = await import('../forums/posts.ts')
+    const post = await fetchPost(params.id, params.brand)
+
+    if (post?.thread) {
+      requestBody.content_url = generateForumPostUrl({
+        brand: params.brand,
+        thread: {
+          category_id: post.thread.category_id,
+          id: post.thread.id
+        }
+      })
+    }
+  } else if (params.type === 'comment') {
+    const { fetchComment } = await import('../railcontent.js')
+    const comment = await fetchComment(params.id)
+
+    if (comment?.content) {
+      const contents = await fetchByRailContentIds([comment.content.id])
+      const content = contents?.[0]
+
+      if (content) {
+        requestBody.content_url = generateCommentUrl({
+          id: comment.id,
+          content: {
+            id: content.id,
+            type: content.type,
+            parentId: content.parentId || content.parent_id,
+            brand: params.brand
+          }
+        })
+      }
+    }
+  }
+
+  return await httpClient.post<ReportResponse>(
     '/api/user-reports/v1/reports',
     requestBody
   )
-
-  return response
 }
 
 /**

package/src/services/urlBuilder.ts

@@ -0,0 +1,297 @@
+/**
+ * @module UrlBuilder
+ * @description URL generation for content across Musora platform
+ *
+ * This is the SINGLE SOURCE OF TRUTH for URL generation.
+ * Used by:
+ * - musora-platform-frontend (via import)
+ * - Mobile apps (via import)
+ * - Backend receives these URLs from frontend and stores them in DB
+ *
+ * Port of: musora-platform-frontend/src/shared/utils/content.utils.ts:generateContentUrl
+ * Related: musora-platform-backend/app/Modules/Content/Builders/UrlBuilder.php (deprecated fallback)
+ */
+
+import { globalConfig } from './config.js'
+import { Brands } from '../lib/brands.js'
+
+/**
+ * Brand type - accepts enum values or string
+ */
+export type Brand = Brands | string
+
+/**
+ * Parameters for generating content URLs
+ */
+export interface ContentUrlParams {
+  /** Content ID (required) */
+  id: number | string
+  /** Content type (required) */
+  type: string
+  /** Parent content ID (optional) */
+  parentId?: number
+  /** Navigation target (optional) */
+  navigateTo?: {
+    id: number
+  }
+  /** Brand (drumeo, pianote, guitareo, singeo, playbass) */
+  brand?: Brand
+}
+
+/**
+ * Forum post object for URL generation
+ */
+export interface ForumPostUrlParams {
+  /** Brand (drumeo, pianote, etc) */
+  brand: Brand
+  /** Thread information */
+  thread: {
+    /** Thread category ID */
+    category_id: number
+    /** Thread ID */
+    id: number
+  }
+}
+
+/**
+ * Playlist object for URL generation
+ */
+export interface PlaylistUrlParams {
+  /** Playlist ID */
+  id: number
+}
+
+/**
+ * Comment object for URL generation
+ */
+export interface CommentUrlParams {
+  /** Comment ID */
+  id: number
+  /** Content information */
+  content: {
+    /** Content ID */
+    id: number
+    /** Content type */
+    type: string
+    /** Parent content ID (optional) */
+    parentId?: number
+    /** Brand */
+    brand: Brand
+  }
+}
+
+/**
+ * Generate a frontend URL for content
+ *
+ * @param params - Content parameters
+ * @returns The generated URL path
+ *
+ * @example
+ * generateContentUrl({ id: 123, type: 'song', brand: 'drumeo' })
+ * // Returns: "/drumeo/songs/transcription/123"
+ *
+ * @example
+ * generateContentUrl({ id: 456, type: 'course-part', parentId: 789, brand: 'pianote' })
+ * // Returns: "/pianote/lessons/course/789/456"
+ *
+ * @example
+ * generateContentUrl({ id: 123, type: 'pack-bundle', navigateTo: { id: 456 }, brand: 'guitareo' })
+ * // Returns: "/guitareo/lessons/pack/123/456"
+ */
+export function generateContentUrl({
+  id,
+  type,
+  parentId,
+  navigateTo,
+  brand = 'drumeo',
+}: ContentUrlParams): string {
+  // Special case: method homepage
+  if (type === 'method') {
+    return `/${brand}/method`
+  }
+
+  // Return fallback if required params missing
+  if (!id || !type) {
+    return '#'
+  }
+
+  // Special cases that don't follow the standard pattern
+  if (type === 'live') {
+    return `/${brand}/lessons/${id}/live`
+  }
+
+  if (type === 'pack') {
+    return `/${brand}/lessons/pack/overview/${id}`
+  }
+
+  if (type === 'pack-bundle') {
+    if (navigateTo?.id) {
+      return `/${brand}/lessons/pack/${id}/${navigateTo.id}`
+    }
+    // Fallback to overview if navigateTo is missing
+    return `/${brand}/lessons/pack/overview/${id}`
+  }
+
+  // Helper function to build URL with common parameters
+  const buildUrl = (typeSegments: string[]): string => {
+    const contentId = navigateTo ? `${id}/${navigateTo.id}` : id
+    const parentSegment = parentId ? `/${parentId}` : ''
+    return `/${brand}/${typeSegments.join('/')}${parentSegment}/${contentId}`
+  }
+
+  // Determine page type (songs, method, or lessons)
+  const songTypes = [
+    'song',
+    'song-tutorial',
+    'song-tutorial-lesson',
+    'transcription',
+    'play-along',
+    'jam-track',
+  ]
+
+  const methodTypes = ['learning-path-v2', 'learning-path-lesson-v2']
+
+  let pageType: string
+  if (songTypes.includes(type)) {
+    pageType = 'songs'
+  } else if (methodTypes.includes(type)) {
+    pageType = 'method'
+  } else {
+    pageType = 'lessons'
+  }
+
+  // Content type routing - maps specific types to URL segments
+  const contentTypeRoutes: Record<string, string> = {
+    // Lesson types
+    'course-lesson': 'course',
+    'guided-course-lesson': 'course',
+    'guided-course': 'course',
+    'pack-bundle-lesson': 'pack',
+    'documentary-lesson': 'documentary',
+    'skill-pack-lesson': 'skill-pack',
+
+    // Method types
+    'learning-path-lesson-v2': 'lesson',
+    'learning-path-v2': 'lesson',
+
+    // Song types
+    song: 'transcription',
+    'song-tutorial': 'tutorial',
+    'song-tutorial-lesson': 'tutorial',
+  }
+
+  // Use specific route if available, otherwise fall back to type as-is
+  const contentTypeSegment = contentTypeRoutes[type] || type
+
+  return buildUrl([pageType, contentTypeSegment])
+}
+
+/**
+ * Generate a full URL with domain
+ *
+ * @param params - Content parameters (same as generateContentUrl)
+ * @returns Full URL with domain from globalConfig.frontendUrl
+ *
+ * @example
+ * generateContentUrlWithDomain({ id: 123, type: 'song' })
+ * // Returns: "https://www.musora.com/drumeo/songs/transcription/123"
+ */
+export function generateContentUrlWithDomain(params: ContentUrlParams): string {
+  const path = generateContentUrl(params)
+
+  if (path === '#') {
+    return '#'
+  }
+
+  return globalConfig.frontendUrl + path
+}
+
+/**
+ * Generate URL for a forum post
+ *
+ * @param post - Forum post object
+ * @param withDomain - Include domain from globalConfig.frontendUrl
+ * @returns Forum post URL
+ *
+ * @example
+ * generateForumPostUrl({ brand: 'drumeo', thread: { category_id: 12, id: 456 }})
+ * // Returns: "/drumeo/forums/threads/12/456"
+ */
+export function generateForumPostUrl(
+  post: ForumPostUrlParams,
+  withDomain: boolean = false
+): string {
+  const path = `/${post.brand}/forums/threads/${post.thread.category_id}/${post.thread.id}`
+
+  if (withDomain) {
+    return globalConfig.frontendUrl + path
+  }
+
+  return path
+}
+
+/**
+ * Generate URL for a user playlist
+ *
+ * @param playlist - Playlist object
+ * @param withDomain - Include domain from globalConfig.frontendUrl
+ * @returns Playlist URL
+ *
+ * @example
+ * generatePlaylistUrl({ id: 123 })
+ * // Returns: "/playlists/123"
+ */
+export function generatePlaylistUrl(
+  playlist: PlaylistUrlParams,
+  withDomain: boolean = false
+): string {
+  const path = `/playlists/${playlist.id}`
+
+  if (withDomain) {
+    return globalConfig.frontendUrl + path
+  }
+
+  return path
+}
+
+/**
+ * Generate URL for a comment (content URL with anchor)
+ *
+ * @param comment - Comment object
+ * @param withDomain - Include domain from globalConfig.frontendUrl
+ * @returns Comment URL with anchor
+ *
+ * @example
+ * generateCommentUrl({
+ *   id: 789,
+ *   content: { id: 123, type: 'song', brand: 'drumeo' }
+ * })
+ * // Returns: "/drumeo/songs/transcription/123#comment-789"
+ */
+export function generateCommentUrl(
+  comment: CommentUrlParams,
+  withDomain: boolean = false
+): string {
+  if (!comment.content) {
+    return '#'
+  }
+
+  const contentUrl = generateContentUrl({
+    id: comment.content.id,
+    type: comment.content.type,
+    parentId: comment.content.parentId,
+    brand: comment.content.brand,
+  })
+
+  if (contentUrl === '#') {
+    return '#'
+  }
+
+  const path = `${contentUrl}#comment-${comment.id}`
+
+  if (withDomain) {
+    return globalConfig.frontendUrl + path
+  }
+
+  return path
+}