musora-content-services 2.160.4 → 2.161.2

package/src/infrastructure/sanity/clients/ContentClient.ts

@@ -0,0 +1,164 @@
+import { SanityClient } from '../SanityClient'
+import { FetchByIdOptions } from '../interfaces/FetchByIdOptions'
+import { ConfigProvider } from '../interfaces/ConfigProvider'
+import { QueryExecutor } from '../interfaces/QueryExecutor'
+
+/**
+ * ContentClient extends SanityClient with content-specific methods
+ * for easier content fetching and management
+ */
+export class ContentClient extends SanityClient {
+  constructor(configProvider?: ConfigProvider, queryExecutor?: QueryExecutor) {
+    super(configProvider, queryExecutor)
+  }
+
+  /**
+   * Fetch content by type and ID (similar to fetchByRailContentId)
+   */
+  public async fetchById<T>(options: FetchByIdOptions): Promise<T | null> {
+    try {
+      const { type, id, fields, includeChildren = false } = options
+      
+      // Build the base query
+      let query = `*[railcontent_id == ${id} && _type == '${type}']`
+      
+      // Build fields string
+      let fieldsString = this.buildFieldsString(type, fields, includeChildren)
+      
+      // Complete the query
+      query += `{${fieldsString}}[0]`
+      
+      return await this.fetchSingle<T>(query)
+    } catch (error: any) {
+      this.handleContentError(error, `fetchById(${JSON.stringify(options)})`)
+      return null
+    }
+  }
+
+  /**
+   * Fetch multiple content items by their IDs
+   */
+  public async fetchByIds<T>(
+    ids: (number | string)[],
+    type?: string,
+    brand?: string,
+    fields?: string[]
+  ): Promise<T[]> {
+    try {
+      if (!ids || ids.length === 0) {
+        return []
+      }
+
+      const idsString = ids.join(',')
+      const typeFilter = type ? ` && _type == '${type}'` : ''
+      const brandFilter = brand ? ` && brand == "${brand}"` : ''
+      const fieldsString = this.buildFieldsString(type || '', fields, false)
+
+      const query = `*[railcontent_id in [${idsString}]${typeFilter}${brandFilter}]{${fieldsString}}`
+
+      const results = await this.fetchList<T>(query)
+
+      // Sort results to match the order of input IDs
+      return results.sort((a: any, b: any) => {
+        const indexA = ids.indexOf(a.id || a.railcontent_id)
+        const indexB = ids.indexOf(b.id || b.railcontent_id)
+        return indexA - indexB
+      })
+          } catch (error: any) {
+        this.handleContentError(error, `fetchByIds([${ids.join(',')}])`)
+        return []
+      }
+  }
+
+  /**
+   * Fetch content by brand and type with basic filtering
+   */
+  public async fetchByBrandAndType<T>(
+    brand: string,
+    type: string,
+    options: {
+      limit?: number
+      offset?: number
+      sortBy?: string
+      fields?: string[]
+    } = {}
+  ): Promise<T[]> {
+    try {
+      const { limit = 10, offset = 0, sortBy = 'published_on desc', fields } = options
+      const fieldsString = this.buildFieldsString(type, fields, false)
+
+      const query = `*[brand == "${brand}" && _type == "${type}"] | order(${sortBy})[${offset}...${offset + limit}]{${fieldsString}}`
+
+      return await this.fetchList<T>(query)
+    } catch (error: any) {
+      this.handleContentError(error, `fetchByBrandAndType(${brand}, ${type})`)
+      return []
+    }
+  }
+
+  /**
+   * Build fields string for queries based on content type and options
+   */
+  private buildFieldsString(type: string, customFields?: string[], includeChildren: boolean = false): string {
+    // Default fields that are commonly used
+    const defaultFields = [
+      "'sanity_id': _id",
+      "'id': railcontent_id",
+      'railcontent_id',
+      'title',
+      "'image': thumbnail.asset->url",
+      "'thumbnail': thumbnail.asset->url",
+      'difficulty',
+      'difficulty_string',
+      'web_url_path',
+      "'url': web_url_path",
+      'published_on',
+      "'type': _type",
+      'brand',
+      'status',
+      "'slug': slug.current",
+      "'permission_id': permission[]->railcontent_id",
+      'length_in_seconds',
+      "'artist': artist->name",
+      "'instructors': instructor[]->name"
+    ]
+
+    // Use custom fields if provided, otherwise use defaults
+    let fields = customFields || defaultFields
+
+    // Add children-related fields if requested
+    if (includeChildren) {
+      fields = [
+        ...fields,
+        "'child_count': coalesce(count(child[]->), 0)",
+        `"lessons": child[]->{
+          "id": railcontent_id,
+          title,
+          "image": thumbnail.asset->url,
+          "instructors": instructor[]->name,
+          length_in_seconds,
+          web_url_path
+        }`
+      ]
+    }
+
+    return fields.join(',\n    ')
+  }
+
+  /**
+   * Handle and rethrow errors with additional context
+   */
+  private handleContentError(error: any, context: string): never {
+    if ('message' in error && 'query' in error) {
+      // This is already a SanityError
+      throw error
+    }
+
+    // Convert to SanityError with context
+    throw {
+      message: error.message || `ContentClient operation failed: ${context}`,
+      query: context,
+      originalError: error,
+    }
+  }
+} 

package/src/infrastructure/sanity/examples/usage.ts

@@ -0,0 +1,101 @@
+import { SanityClient, ContentClient } from '../index'
+
+/**
+ * Example usage of the SanityClient and ContentClient
+ * 
+ * This demonstrates how to use both the base SanityClient for raw queries
+ * and the ContentClient for content-specific operations.
+ * Both clients automatically use the global configuration from the config service.
+ */
+
+// Create client instances
+const sanityClient = new SanityClient()
+const contentClient = new ContentClient()
+
+// Example: Fetch a single song by ID using the ContentClient
+export async function fetchSongExample(songId: number) {
+  return await contentClient.fetchById({
+    type: 'song',
+    id: songId
+  })
+}
+
+// Example: Fetch a single song by ID with custom fields
+export async function fetchSongWithCustomFieldsExample(songId: number) {
+  return await contentClient.fetchById({
+    type: 'song',
+    id: songId,
+    fields: [
+      "'id': railcontent_id",
+      'title',
+      "'artist': artist->name",
+      "'thumbnail': thumbnail.asset->url",
+      'difficulty_string',
+      'published_on',
+      'album',
+      'soundslice'
+    ]
+  })
+}
+
+// Example: Fetch a course with its children/lessons
+export async function fetchCourseWithLessonsExample(courseId: number) {
+  return await contentClient.fetchById({
+    type: 'course',
+    id: courseId,
+    includeChildren: true
+  })
+}
+
+// Example: Fetch multiple content items by IDs
+export async function fetchMultipleSongsExample(songIds: number[]) {
+  return await contentClient.fetchByIds(songIds, 'song', 'drumeo')
+}
+
+// Example: Fetch content by brand and type
+export async function fetchDrumeoSongsExample() {
+  return await contentClient.fetchByBrandAndType('drumeo', 'song', {
+    limit: 20,
+    sortBy: 'published_on desc'
+  })
+}
+
+// Example: Fetch multiple songs with pagination
+export async function fetchSongsExample(brand: string, page: number = 1, limit: number = 10) {
+  const start = (page - 1) * limit
+  const end = start + limit
+  
+  const query = `*[_type == "song" && brand == "${brand}"] | order(published_on desc)[${start}...${end}]{
+    "id": railcontent_id,
+    title,
+    "artist": artist->name,
+    "thumbnail": thumbnail.asset->url,
+    difficulty_string,
+    published_on
+  }`
+  
+  return await sanityClient.fetchList(query)
+}
+
+// Example: Execute a complex query that returns custom structure
+export async function fetchSongsWithCountExample(brand: string) {
+  const query = `{
+    "songs": *[_type == "song" && brand == "${brand}"] | order(published_on desc)[0...10]{
+      "id": railcontent_id,
+      title,
+      "artist": artist->name
+    },
+    "total": count(*[_type == "song" && brand == "${brand}"])
+  }`
+  
+  return await sanityClient.executeQuery(query)
+}
+
+// Example: Using with parameters (though GROQ doesn't support parameters like SQL)
+export async function fetchSongWithParamsExample(songId: number) {
+  // Note: Sanity GROQ doesn't support parameterized queries like SQL
+  // Parameters would be used for client-side processing if needed
+  const query = `*[_type == "song" && railcontent_id == ${songId}][0]`
+  
+  return await sanityClient.fetchSingle(query, { songId })
+} 

package/src/infrastructure/sanity/executors/FetchQueryExecutor.ts

@@ -0,0 +1,110 @@
+import { QueryExecutor } from '../interfaces/QueryExecutor'
+import { SanityQuery } from '../interfaces/SanityQuery'
+import { SanityResponse } from '../interfaces/SanityResponse'
+import { SanityConfig } from '../interfaces/SanityConfig'
+import { SanityError } from '../interfaces/SanityError'
+
+const GET_URL_MAX_LENGTH = 8000
+
+export class FetchQueryExecutor implements QueryExecutor {
+  async execute<T>(query: SanityQuery, config: SanityConfig): Promise<SanityResponse<T>> {
+    const baseUrl = this.buildUrl(config)
+    const { url, options } = this.buildRequest(baseUrl, query, config)
+
+    if (config.debug) {
+      console.log('Sanity Query:', query.query)
+    }
+
+    try {
+      const response = await fetch(url, options)
+
+      if (!response.ok) {
+        throw await this.createSanityError(response, query)
+      }
+
+      const result = await response.json()
+      
+      if (config.debug) {
+        console.log('Sanity Results:', result)
+      }
+
+      return result as SanityResponse<T>
+    } catch (error: any) {
+      if ('message' in error && 'query' in error) {
+        throw error as SanityError
+      }
+
+      throw {
+        message: error.message || 'Sanity query execution failed',
+        query: query.query,
+        params: query.params,
+        originalError: error,
+      } as SanityError
+    }
+  }
+
+  private buildUrl(config: SanityConfig): string {
+    const perspective = config.perspective ?? 'published'
+    const api = config.useCachedAPI ? 'apicdn' : 'api'
+    return `https://${config.projectId}.${api}.sanity.io/v${config.version}/data/query/${config.dataset}?perspective=${perspective}`
+  }
+
+  private buildRequest(
+    baseUrl: string,
+    query: SanityQuery,
+    config: SanityConfig
+  ): { url: string; options: RequestInit } {
+    const authHeader: Record<string, string> = config.token
+      ? { Authorization: `Bearer ${config.token}` }
+      : {}
+
+    const hasParams = query.params && Object.keys(query.params).length > 0
+    const encodedQuery = encodeURIComponent(query.query)
+    const getUrl = `${baseUrl}&query=${encodedQuery}`
+    const canUseGet = !hasParams && getUrl.length < GET_URL_MAX_LENGTH
+
+    if (canUseGet) {
+      return {
+        url: getUrl,
+        options: {
+          method: 'GET',
+          headers: authHeader,
+        },
+      }
+    }
+
+    return {
+      url: baseUrl,
+      options: {
+        method: 'POST',
+        headers: {
+          ...authHeader,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(query),
+      },
+    }
+  }
+
+  private async createSanityError(
+    response: Response,
+    query: SanityQuery
+  ): Promise<SanityError> {
+    let errorMessage = `Sanity API error: ${response.status} - ${response.statusText}`
+    
+    try {
+      const errorBody = await response.json()
+      if (errorBody.message) {
+        errorMessage = errorBody.message
+      }
+    } catch (e) {
+      // If we can't parse the error body, use the default message
+    }
+
+    return {
+      message: errorMessage,
+      query: query.query,
+      params: query.params,
+    }
+  }
+} 

package/src/infrastructure/sanity/index.ts

@@ -0,0 +1,19 @@
+// Main clients
+export { SanityClient } from './SanityClient'
+export { ContentClient } from './clients/ContentClient'
+
+// Interfaces
+export type { SanityConfig } from './interfaces/SanityConfig'
+export type { SanityQuery } from './interfaces/SanityQuery'
+export type { SanityResponse } from './interfaces/SanityResponse'
+export type { SanityError } from './interfaces/SanityError'
+export type { QueryExecutor } from './interfaces/QueryExecutor'
+export type { ConfigProvider } from './interfaces/ConfigProvider'
+export type { FetchByIdOptions } from './interfaces/FetchByIdOptions'
+
+// Providers
+export { DefaultConfigProvider } from './providers/DefaultConfigProvider'
+
+// Executors
+export { FetchQueryExecutor } from './executors/FetchQueryExecutor'
+

package/src/infrastructure/sanity/interfaces/ConfigProvider.ts

@@ -0,0 +1,6 @@
+import { SanityConfig } from './SanityConfig'
+
+export interface ConfigProvider {
+  getConfig(): SanityConfig
+}
+

package/src/infrastructure/sanity/interfaces/FetchByIdOptions.ts

@@ -0,0 +1,7 @@
+export interface FetchByIdOptions {
+  type: string
+  id: number | string
+  fields?: string[]
+  includeChildren?: boolean
+}
+

package/src/infrastructure/sanity/interfaces/QueryExecutor.ts

@@ -0,0 +1,8 @@
+import { SanityQuery } from './SanityQuery'
+import { SanityResponse } from './SanityResponse'
+import { SanityConfig } from './SanityConfig'
+
+export interface QueryExecutor {
+  execute<T>(query: SanityQuery, config: SanityConfig): Promise<SanityResponse<T>>
+}
+

package/src/infrastructure/sanity/interfaces/SanityConfig.ts

@@ -0,0 +1,10 @@
+export interface SanityConfig {
+  projectId: string
+  dataset: string
+  version: string
+  token: string
+  perspective?: string
+  useCachedAPI?: boolean
+  debug?: boolean
+}
+

package/src/infrastructure/sanity/interfaces/SanityError.ts

@@ -0,0 +1,7 @@
+export interface SanityError {
+  message: string
+  query?: string
+  params?: Record<string, any>
+  originalError?: any
+}
+

package/src/infrastructure/sanity/interfaces/SanityQuery.ts

@@ -0,0 +1,5 @@
+export interface SanityQuery {
+  query: string
+  params?: Record<string, any>
+}
+

package/src/infrastructure/sanity/interfaces/SanityResponse.ts

@@ -0,0 +1,6 @@
+export interface SanityResponse<T = any> {
+  result: T
+  ms: number
+  query: string
+}
+

package/src/infrastructure/sanity/providers/DefaultConfigProvider.ts

@@ -0,0 +1,38 @@
+import { ConfigProvider } from '../interfaces/ConfigProvider'
+import { SanityConfig } from '../interfaces/SanityConfig'
+import { globalConfig } from '../../../services/config.js'
+
+export class DefaultConfigProvider implements ConfigProvider {
+  getConfig(): SanityConfig {
+    if (!globalConfig.sanityConfig) {
+      throw new Error('Sanity configuration is not available in globalConfig')
+    }
+
+    const config = globalConfig.sanityConfig
+
+    // Validate required fields
+    if (!config.token) {
+      throw new Error('Sanity token is missing in configuration')
+    }
+    if (!config.projectId) {
+      throw new Error('Sanity projectId is missing in configuration')
+    }
+    if (!config.dataset) {
+      throw new Error('Sanity dataset is missing in configuration')
+    }
+    if (!config.version) {
+      throw new Error('Sanity version is missing in configuration')
+    }
+
+    return {
+      projectId: config.projectId,
+      dataset: config.dataset,
+      version: config.version,
+      token: config.token,
+      perspective: (config as any).perspective ?? 'published',
+      useCachedAPI: (config as any).useCachedAPI ?? false,
+      debug: (config as any).debug ?? false,
+    }
+  }
+}
+

package/src/lib/sanity/decorators/base.ts

@@ -0,0 +1,142 @@
+export interface Decoratable {
+  children?: Decoratable[]
+  [key: string]: unknown
+}
+
+export type DecorateFn<T, V> = (item: T) => V
+
+export type DecorateFnAsync<T, V> = (item: T) => Promise<V>
+
+export interface FieldDecorator<T extends Decoratable, K extends string = string, V = unknown> {
+  field: K
+  compute: DecorateFn<T, V>
+  recurse?: boolean
+}
+
+export interface FieldDecoratorAsync<
+  T extends Decoratable,
+  K extends string = string,
+  V = unknown,
+> {
+  field: K
+  compute: DecorateFnAsync<T, V>
+  recurse?: boolean
+}
+
+type Decorated<T, K extends string, V> = T & { [P in K]: V }
+
+const MAX_CHILD_DEPTH = 3
+
+export function decorate<T extends Decoratable, K extends string, V>(
+  items: T[],
+  field: K,
+  compute: DecorateFn<T, V>
+): Decorated<T, K, V>[]
+export function decorate<T extends Decoratable, K extends string, V>(
+  items: T,
+  field: K,
+  compute: DecorateFn<T, V>
+): Decorated<T, K, V>
+export function decorate<T extends Decoratable, K extends string, V>(
+  items: T | T[],
+  field: K,
+  compute: DecorateFn<T, V>
+): Decorated<T, K, V> | Decorated<T, K, V>[] {
+  const list = Array.isArray(items) ? items : [items]
+  for (const item of list) visit(item, [{ field, compute }], 0)
+  return items as Decorated<T, K, V> | Decorated<T, K, V>[]
+}
+
+export function decorateAll<T extends Decoratable>(
+  items: T[],
+  decorators: ReadonlyArray<FieldDecorator<T>>
+): T[]
+export function decorateAll<T extends Decoratable>(
+  items: T,
+  decorators: ReadonlyArray<FieldDecorator<T>>
+): T
+export function decorateAll<T extends Decoratable>(
+  items: T | T[],
+  decorators: ReadonlyArray<FieldDecorator<T>>
+): T | T[] {
+  const list = Array.isArray(items) ? items : [items]
+  for (const item of list) visit(item, decorators, 0)
+  return items
+}
+
+function visit<T extends Decoratable>(
+  item: T,
+  decorators: ReadonlyArray<FieldDecorator<T, string, unknown>>,
+  depth: number
+): void {
+  if (!item) return
+  const target = item as Record<string, unknown>
+  for (const { field, compute } of decorators) {
+    target[field] = compute(item)
+  }
+  if (depth >= MAX_CHILD_DEPTH - 1) return
+  const children = item.children
+  if (!Array.isArray(children)) return
+  const recursing = decorators.filter((d) => d.recurse !== false)
+  if (recursing.length === 0) return
+  for (const child of children) {
+    visit(child as T, recursing, depth + 1)
+  }
+}
+
+export function decorateAsync<T extends Decoratable, K extends string, V>(
+  items: T[],
+  field: K,
+  compute: DecorateFnAsync<T, V>
+): Promise<Decorated<T, K, V>[]>
+export function decorateAsync<T extends Decoratable, K extends string, V>(
+  items: T,
+  field: K,
+  compute: DecorateFnAsync<T, V>
+): Promise<Decorated<T, K, V>>
+export function decorateAsync<T extends Decoratable, K extends string, V>(
+  items: T | T[],
+  field: K,
+  compute: DecorateFnAsync<T, V>
+): Promise<Decorated<T, K, V> | Decorated<T, K, V>[]> {
+  return decorateAllAsync(items as T[], [{ field, compute }]) as Promise<
+    Decorated<T, K, V> | Decorated<T, K, V>[]
+  >
+}
+
+export function decorateAllAsync<T extends Decoratable>(
+  items: T[],
+  decorators: ReadonlyArray<FieldDecoratorAsync<T>>
+): Promise<T[]>
+export function decorateAllAsync<T extends Decoratable>(
+  items: T,
+  decorators: ReadonlyArray<FieldDecoratorAsync<T>>
+): Promise<T>
+export async function decorateAllAsync<T extends Decoratable>(
+  items: T | T[],
+  decorators: ReadonlyArray<FieldDecoratorAsync<T>>
+): Promise<T | T[]> {
+  const list = Array.isArray(items) ? items : [items]
+  await Promise.all(list.map((item) => visitAsync(item, decorators, 0)))
+  return items
+}
+
+async function visitAsync<T extends Decoratable>(
+  item: T,
+  decorators: ReadonlyArray<FieldDecoratorAsync<T, string, unknown>>,
+  depth: number
+): Promise<void> {
+  if (!item) return
+  const target = item as Record<string, unknown>
+  await Promise.all(
+    decorators.map(async ({ field, compute }) => {
+      target[field] = await compute(item)
+    })
+  )
+  if (depth >= MAX_CHILD_DEPTH - 1) return
+  const children = item.children
+  if (!Array.isArray(children)) return
+  const recursing = decorators.filter((d) => d.recurse !== false)
+  if (recursing.length === 0) return
+  await Promise.all(children.map((child) => visitAsync(child as T, recursing, depth + 1)))
+}