musora-content-services 2.185.1 → 2.186.1

package/.claude/settings.local.json

@@ -20,6 +20,11 @@
     "asana",
     "nightwatch",
     "sentry",
-    "customerio"
+    "customerio",
+    "vercel",
+    "cloudflare"
+  ],
+  "disabledMcpjsonServers": [
+    "mysql-archive"
   ]
 }

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [2.186.1](https://github.com/railroadmedia/musora-content-services/compare/v2.186.0...v2.186.1) (2026-10-19)
+
+
+### Bug Fixes
+
+* guard against null awards list when Sanity fetch fails ([#1053](https://github.com/railroadmedia/musora-content-services/issues/1053)) ([77f0bf7](https://github.com/railroadmedia/musora-content-services/commit/77f0bf711c2fcc5a5e47cb1a8d0328f670f5107d))
+* preserve resume time when duplicating playlist progress  ([#1045](https://github.com/railroadmedia/musora-content-services/issues/1045)) ([d62d394](https://github.com/railroadmedia/musora-content-services/commit/d62d394542b170741c818182405ca53efde046d1)), closes [#1079](https://github.com/railroadmedia/musora-content-services/issues/1079)
+* replace @/ alias imports with relative paths in src ([bc22248](https://github.com/railroadmedia/musora-content-services/commit/bc22248264a029904c7f8bae403c257268da47c6))
+
+## [2.186.0](https://github.com/railroadmedia/musora-content-services/compare/v2.185.1...v2.186.0) (2026-10-16)
+
+
+### Features
+
+* **MU2-1384:** Port recommendations to the new sanity builders ([#1058](https://github.com/railroadmedia/musora-content-services/issues/1058)) ([0e2e41f](https://github.com/railroadmedia/musora-content-services/commit/0e2e41f86e26e16af18b894ab2472d54e3008022))
+* **MU2-2025:** Add promotional campaign queries and claim state ([#1081](https://github.com/railroadmedia/musora-content-services/issues/1081)) ([921ab1e](https://github.com/railroadmedia/musora-content-services/commit/921ab1effee488253413fd42146377e986571e45))
+
 ### [2.185.1](https://github.com/railroadmedia/musora-content-services/compare/v2.185.0...v2.185.1) (2026-10-06)
 
 ## [2.185.0](https://github.com/railroadmedia/musora-content-services/compare/v2.184.1...v2.185.0) (2026-10-01)

package/jest.config.js

@@ -28,7 +28,6 @@ export default {
     'src/**/*.{js,ts}',
     '!src/services/sanity.js',
     '!src/services/railcontent.js',
-    '!src/services/recommendations.js',
     '!src/index.js',
     '!src/index.d.ts',
     '!src/services/user/account.ts',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "2.185.1",
+  "version": "2.186.1",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "type": "module",

package/src/index.d.ts

@@ -81,7 +81,6 @@ import {
 	getNewAndUpcoming,
 	getOwnedContent,
 	getRecent,
-	getRecommendedForYou,
 	getScheduleContentRows,
 	getTabResults
 } from './services/content.js';
@@ -217,6 +216,14 @@ import {
 	fetchMarketingTestimonials
 } from './services/marketing/marketing.ts';
 
+import {
+	claimPromotionalCampaign,
+	dismissPromotionalCampaign,
+	fetchAvailablePromotionalCampaigns,
+	fetchPromotionalCampaigns,
+	fetchUserCampaignStates
+} from './services/marketing/promotions.ts';
+
 import {
 	acceptInvite,
 	createAccount,
@@ -351,10 +358,11 @@ import {
 
 import {
 	fetchSimilarItems,
+	getRecommendedForYou,
 	rankCategories,
 	rankItems,
 	recommendations
-} from './services/recommendations.js';
+} from './services/recommendations.ts';
 
 import {
 	getReportIssueOptions,
@@ -585,6 +593,7 @@ declare module 'musora-content-services' {
 		buildEntityAndTotalQuery,
 		buildImageSRC,
 		calculateLongestStreaks,
+		claimPromotionalCampaign,
 		clearAllCachedData,
 		clearState,
 		closeComment,
@@ -625,6 +634,7 @@ declare module 'musora-content-services' {
 		deleteProfilePicture,
 		deleteThread,
 		deleteUserActivity,
+		dismissPromotionalCampaign,
 		doesUserHaveMembership,
 		duplicatePlaylist,
 		editComment,
@@ -638,6 +648,7 @@ declare module 'musora-content-services' {
 		fetchArtistBySlug,
 		fetchArtistLessons,
 		fetchArtists,
+		fetchAvailablePromotionalCampaigns,
 		fetchBrandsByContentIds,
 		fetchByRailContentId,
 		fetchByRailContentIds,
@@ -704,6 +715,7 @@ declare module 'musora-content-services' {
 		fetchPost,
 		fetchPosts,
 		fetchPracticeGoals,
+		fetchPromotionalCampaigns,
 		fetchPublicAnnouncement,
 		fetchQuizAnswers,
 		fetchRecent,
@@ -732,6 +744,7 @@ declare module 'musora-content-services' {
 		fetchUninterests,
 		fetchUnreadCount,
 		fetchUpcomingEvents,
+		fetchUserCampaignStates,
 		fetchUserPermissions,
 		fetchUserPlaylists,
 		fetchUserPracticeMeta,

package/src/index.js

@@ -85,7 +85,6 @@ import {
 	getNewAndUpcoming,
 	getOwnedContent,
 	getRecent,
-	getRecommendedForYou,
 	getScheduleContentRows,
 	getTabResults
 } from './services/content.js';
@@ -221,6 +220,14 @@ import {
 	fetchMarketingTestimonials
 } from './services/marketing/marketing.ts';
 
+import {
+	claimPromotionalCampaign,
+	dismissPromotionalCampaign,
+	fetchAvailablePromotionalCampaigns,
+	fetchPromotionalCampaigns,
+	fetchUserCampaignStates
+} from './services/marketing/promotions.ts';
+
 import {
 	acceptInvite,
 	createAccount,
@@ -355,10 +362,11 @@ import {
 
 import {
 	fetchSimilarItems,
+	getRecommendedForYou,
 	rankCategories,
 	rankItems,
 	recommendations
-} from './services/recommendations.js';
+} from './services/recommendations.ts';
 
 import {
 	getReportIssueOptions,
@@ -584,6 +592,7 @@ export {
 	buildEntityAndTotalQuery,
 	buildImageSRC,
 	calculateLongestStreaks,
+	claimPromotionalCampaign,
 	clearAllCachedData,
 	clearState,
 	closeComment,
@@ -624,6 +633,7 @@ export {
 	deleteProfilePicture,
 	deleteThread,
 	deleteUserActivity,
+	dismissPromotionalCampaign,
 	doesUserHaveMembership,
 	duplicatePlaylist,
 	editComment,
@@ -637,6 +647,7 @@ export {
 	fetchArtistBySlug,
 	fetchArtistLessons,
 	fetchArtists,
+	fetchAvailablePromotionalCampaigns,
 	fetchBrandsByContentIds,
 	fetchByRailContentId,
 	fetchByRailContentIds,
@@ -703,6 +714,7 @@ export {
 	fetchPost,
 	fetchPosts,
 	fetchPracticeGoals,
+	fetchPromotionalCampaigns,
 	fetchPublicAnnouncement,
 	fetchQuizAnswers,
 	fetchRecent,
@@ -731,6 +743,7 @@ export {
 	fetchUninterests,
 	fetchUnreadCount,
 	fetchUpcomingEvents,
+	fetchUserCampaignStates,
 	fetchUserPermissions,
 	fetchUserPlaylists,
 	fetchUserPracticeMeta,

package/src/lib/ads/async-either.ts

@@ -0,0 +1,148 @@
+import { Either } from './either'
+
+const toError = (error: unknown, message?: string): Error =>
+  error instanceof Error
+    ? error
+    : new Error(message ?? String(error ?? 'AsyncEither.attempt failed'))
+
+/**
+ * An {@link Either} that has not resolved yet, so a chain can keep going across asynchronous
+ * steps instead of dropping back into `.then()` at every one. Not a `TaskEither`: the work is
+ * already running when the AsyncEither is built.
+ * @example
+ * const lessons = await AsyncEither.of(run<Lesson[]>(groq))
+ *   .map((lessons) => lessons ?? [])
+ *   .mapAsync((lessons) => decorateNavigateTo(lessons))
+ *   .ltap((error) => console.error(error.message))
+ *   .recover([])
+ */
+export class AsyncEither<L, R> implements PromiseLike<Either<L, R>> {
+  private constructor(private readonly promise: Promise<Either<L, R>>) {}
+
+  /** @param promise - the pending Either to lift */
+  static of<L, R>(promise: Promise<Either<L, R>>): AsyncEither<L, R> {
+    return new AsyncEither(promise)
+  }
+
+  static attempt<R>(fn: () => Promise<R>, message?: string): AsyncEither<Error, R>
+  static attempt<R, L>(
+    fn: () => Promise<R>,
+    onError: (error: unknown) => L
+  ): AsyncEither<L, R>
+  /**
+   * @param fn - the work to run; a rejection becomes a Left instead of propagating
+   * @param onError - a message used when `fn` rejects with a non-Error, or a function receiving
+   * the rejection untouched when the left has to carry more than a message
+   * @example
+   * AsyncEither.attempt(() => fetchStates(slugs), 'failed to fetch campaign state')
+   * @example
+   * AsyncEither.attempt(
+   *   () => client.query(groq),
+   *   (error) => new SanityQueryError('Sanity query failed', groq, error)
+   * )
+   */
+  static attempt<R, L>(
+    fn: () => Promise<R>,
+    onError?: string | ((error: unknown) => L)
+  ): AsyncEither<L | Error, R> {
+    const message = typeof onError === 'string' ? onError : undefined
+    const toLeft =
+      typeof onError === 'function' ? onError : (error: unknown) => toError(error, message)
+
+    return AsyncEither.of(
+      fn().then(
+        (value) => Either.right<L | Error, R>(value),
+        (error) => Either.left<L | Error, R>(toLeft(error))
+      )
+    )
+  }
+
+  /** @param fn - maps the right value once it resolves */
+  map<T>(fn: (r: R) => T): AsyncEither<L, T> {
+    return AsyncEither.of(this.promise.then((either) => either.map(fn)))
+  }
+
+  /** @param fn - maps the right value with an asynchronous function; a rejection propagates */
+  mapAsync<T>(fn: (r: R) => Promise<T>): AsyncEither<L, T> {
+    return AsyncEither.of(this.promise.then((either) => either.mapAsync(fn)))
+  }
+
+  /**
+   * @param fn - maps the right value to another AsyncEither, flattening the result; its left type
+   * may differ, in which case the result carries the union of both
+   */
+  flatMap<T, E = L>(fn: (r: R) => AsyncEither<E, T>): AsyncEither<L | E, T> {
+    return AsyncEither.of(
+      this.promise.then((either) =>
+        either.fold(
+          (l) => Promise.resolve(Either.left<L | E, T>(l)),
+          (r) => fn(r).promise as Promise<Either<L | E, T>>
+        )
+      )
+    )
+  }
+
+  /** @param fn - maps the left value once it resolves */
+  lmap<T>(fn: (l: L) => T): AsyncEither<T, R> {
+    return AsyncEither.of(this.promise.then((either) => either.lmap(fn)))
+  }
+
+  /** @param fn - maps the left value to another AsyncEither, flattening the result */
+  lflatMap<T>(fn: (l: L) => AsyncEither<T, R>): AsyncEither<T, R> {
+    return AsyncEither.of(
+      this.promise.then((either) =>
+        either.fold(
+          (l) => fn(l).promise,
+          (r) => Promise.resolve(Either.right<T, R>(r))
+        )
+      )
+    )
+  }
+
+  /** @param fn - visits the right value without modifying it */
+  tap(fn: (r: R) => void): AsyncEither<L, R> {
+    return AsyncEither.of(this.promise.then((either) => either.tap(fn)))
+  }
+
+  /** @param fn - visits the left value without modifying it */
+  ltap(fn: (l: L) => void): AsyncEither<L, R> {
+    return AsyncEither.of(this.promise.then((either) => either.ltap(fn)))
+  }
+
+  /**
+   * @param onLeft - handles the left value
+   * @param onRight - handles the right value
+   * @returns {Promise<T | U>}
+   */
+  fold<T, U>(onLeft: (l: L) => T, onRight: (r: R) => U): Promise<T | U> {
+    return this.promise.then((either) => either.fold(onLeft, onRight))
+  }
+
+  /**
+   * @param defaultValue - returned when the resolved Either is a Left
+   * @returns {Promise<R>}
+   */
+  recover(defaultValue: R): Promise<R> {
+    return this.promise.then((either) => either.recover(defaultValue))
+  }
+
+  /**
+   * @param error - thrown instead of the left, or used as the message of the thrown Error
+   * @returns {Promise<R>}
+   */
+  orFail(error?: string | Error): Promise<R> {
+    return this.promise.then((either) => either.orFail(error))
+  }
+
+  /** @returns {Promise<Either<L, R>>} */
+  unlift(): Promise<Either<L, R>> {
+    return this.promise
+  }
+
+  then<T = Either<L, R>, U = never>(
+    onfulfilled?: ((either: Either<L, R>) => T | PromiseLike<T>) | null,
+    onrejected?: ((reason: unknown) => U | PromiseLike<U>) | null
+  ): Promise<T | U> {
+    return this.promise.then(onfulfilled, onrejected)
+  }
+}

package/src/lib/ads/coproduct.ts

@@ -84,6 +84,42 @@ export abstract class Coproduct<L, R>
    */
   abstract fold<T, U>(onLeft: (l: L) => T, onRight: (r: R) => U): T | U
 
+  /**
+   * Unwraps the right value, throwing the left instead of returning it. Use at the edge of a
+   * chain where a failure has to become an exception.
+   * @param error - thrown instead of the left, or used as the message of the thrown Error
+   * @throws the left value when it is an `Error`, otherwise an `Error` wrapping it
+   * @example
+   * Coproduct.right(5).orFail()                          // 5
+   * Coproduct.left(new Error('bad')).orFail()            // throws Error('bad')
+   * Coproduct.left('bad').orFail('error during request') // throws Error('error during request')
+   * Coproduct.left('bad').orFail(new HttpError(502))     // throws HttpError(502)
+   */
+  orFail(error?: string | Error): R {
+    return this.fold(
+      (l) => {
+        throw Coproduct.toError(l, error)
+      },
+      (r) => r
+    )
+  }
+
+  private static toError<L>(value: L, error?: string | Error): Error {
+    if (error instanceof Error) {
+      return error
+    }
+
+    if (typeof error === 'string') {
+      return new Error(error)
+    }
+
+    if (value instanceof Error) {
+      return value
+    }
+
+    return new Error(typeof value === 'string' ? value : 'Coproduct.orFail called on a Left')
+  }
+
   /** Convenience {@link fold} that applies the same `fn` regardless of side. */
   foldMap<T>(initial: T, fn: (acc: T, value: L | R) => T): T {
     return this.fold(

package/src/lib/sanity/decorators/navigate-to.ts

@@ -4,7 +4,7 @@ import {
   CollectionParameter,
   STATE,
 } from '../../../services/sync/models/ContentProgress'
-import { Progress } from '@/services/progress'
+import { Progress } from '../../../services/progress'
 
 export const NAVIGATE_TO_FIELD = 'navigateTo' as const
 
@@ -15,9 +15,10 @@ const NAVIGABLE_TYPES = [
   'song-tutorial',
   COLLECTION_TYPE.LEARNING_PATH,
   'skill-pack',
+  'documentary',
 ] as const
 
-const COURSE_FLOW_TYPES = ['course', 'skill-pack', 'song-tutorial']
+const COURSE_FLOW_TYPES = ['course', 'skill-pack', 'song-tutorial', 'documentary']
 const GUIDED_FLOW_TYPES = ['guided-course', COLLECTION_TYPE.LEARNING_PATH]
 const TWO_DEPTH_TYPES = ['course-collection']
 
@@ -46,11 +47,18 @@ export type WithNavigateTo<T extends NavigateToDecoratable> = T & {
   navigateTo: NavigateTo | null
 }
 
+const definedChildrenOf = (content: NavigateToDecoratable): NavigateToDecoratable[] =>
+  (content.children ?? []).filter(Boolean)
+
 function buildNavigateTo(
-  content: NavigateToDecoratable,
+  content: NavigateToDecoratable | null | undefined,
   child: NavigateTo | null = null,
   collection: NavigateTo['collection'] = null
-): NavigateTo {
+): NavigateTo | null {
+  if (!content) {
+    return null
+  }
+
   return {
     id: content.id,
     type: content.type,
@@ -72,10 +80,10 @@ async function prefetchStates(items: NavigateToDecoratable[]): Promise<NavigateC
   for (const item of items) {
     if (!item || !NAVIGABLE_TYPES.includes(item.type as (typeof NAVIGABLE_TYPES)[number])) continue
     ids.add(item.id)
-    for (const child of item.children ?? []) {
+    for (const child of definedChildrenOf(item)) {
       ids.add(child.id)
       if (TWO_DEPTH_TYPES.includes(item.type)) {
-        for (const grandchild of child.children ?? []) {
+        for (const grandchild of definedChildrenOf(child)) {
           ids.add(grandchild.id)
         }
       }
@@ -92,8 +100,8 @@ async function computeNavigateTo(
 ): Promise<NavigateTo | null> {
   if (!NAVIGABLE_TYPES.includes(content.type as (typeof NAVIGABLE_TYPES)[number])) return null
 
-  const children = content.children
-  if (!children || children.length === 0) return null
+  const children = definedChildrenOf(content)
+  if (children.length === 0) return null
 
   const contentState = ctx?.states.get(content.id) ?? (await Progress.state(content.id))
   if (contentState !== STATE.STARTED) {
@@ -117,14 +125,12 @@ async function computeNavigateTo(
       lastInteractedStatus === STATE.STARTED
         ? lastInteractedId
         : Progress.incompleteLesson(childrenStates, content.type, lastInteractedId)
-    const target = childrenById.get(targetId)
-    return target ? buildNavigateTo(target) : null
+    return buildNavigateTo(childrenById.get(targetId))
   }
 
   if (GUIDED_FLOW_TYPES.includes(content.type)) {
     const targetId = Progress.incompleteLesson(childrenStates, content.type, lastInteractedId)
-    const target = childrenById.get(targetId)
-    return target ? buildNavigateTo(target) : null
+    return buildNavigateTo(childrenById.get(targetId))
   }
 
   if (TWO_DEPTH_TYPES.includes(content.type)) {
@@ -147,10 +153,10 @@ export function navigateToDecorator(
   }
 }
 
-export function decorateNavigateTo<T extends NavigateToDecoratable>(
+export async function decorateNavigateTo<T extends NavigateToDecoratable>(
   items: T[]
 ): Promise<WithNavigateTo<T>[]>
-export function decorateNavigateTo<T extends NavigateToDecoratable>(
+export async function decorateNavigateTo<T extends NavigateToDecoratable>(
   items: T
 ): Promise<WithNavigateTo<T>>
 export async function decorateNavigateTo<T extends NavigateToDecoratable>(

package/src/lib/sanity/examples.ts

@@ -25,19 +25,20 @@ const publishedSongs = (brand: string) =>
   f.combine(f.type('song'), f.statusIn(['published']), f.defined('railcontent_id'), f.brand(brand))
 
 export async function fetchSongTitles(brand: string) {
-  const result = await groq()
+  const result = await groq<Song[]>()
     .and(publishedSongs(brand))
     .order('published_on desc')
     .slice(0, 10)
     .select('_id', 'title', 'railcontent_id')
-    .run<Song[]>()
+    .default([])
+    .run()
 
   return result.fold(
     (error) => {
       console.error(`${error.name}: ${error.message}`, error.groq)
       return []
     },
-    (songs) => songs ?? []
+    (songs) => songs
   )
 }
 
@@ -105,27 +106,28 @@ interface Lesson {
 }
 
 export async function fetchLessonsWithoutPermissions(brand: string) {
-  const result = await groq().and(f.brand(brand)).slice(0, 10).run<Lesson[]>()
+  const result = await groq<Lesson[]>().and(f.brand(brand)).slice(0, 10).default([]).run()
 
   return result
     .map((lessons) =>
-      decorateAll<Lesson>(lessons ?? [], [pageTypeDecorator as FieldDecorator<Lesson>])
+      decorateAll<Lesson>(lessons, [pageTypeDecorator as FieldDecorator<Lesson>])
     )
     .recover([])
 }
 
 export async function fetchDecoratedLessons(brand: string) {
   const [result, permissions] = await Promise.all([
-    groq()
+    groq<Lesson[]>()
       .and(f.combine(f.typeIn(['course']), f.brand(brand)))
       .slice(0, 10)
-      .run<Lesson[]>(),
+      .default([])
+      .run(),
     fetchUserPermissions(),
   ])
 
   return result
     .map((lessons) =>
-      decorateAll<Lesson>(lessons ?? [], [
+      decorateAll<Lesson>(lessons, [
         accessDecorator(permissions) as FieldDecorator<Lesson>,
         lifetimeUpgradeDecorator(permissions) as FieldDecorator<Lesson>,
         pageTypeDecorator as FieldDecorator<Lesson>,
@@ -135,18 +137,15 @@ export async function fetchDecoratedLessons(brand: string) {
 }
 
 export async function fetchLessonsWithNavigation(brand: string) {
-  const [result, permissions] = await Promise.all([
-    groq().and(f.brand(brand)).slice(0, 10).run<Lesson[]>(),
-    fetchUserPermissions(),
-  ])
+  const lessons = groq<Lesson[]>().and(f.brand(brand)).slice(0, 10).default([]).run()
+  const permissions = await fetchUserPermissions()
 
-  const decorated = await result
+  return lessons
     .map((lessons) =>
-      decorateAll<Lesson>(lessons ?? [], [accessDecorator(permissions) as FieldDecorator<Lesson>])
+      decorateAll<Lesson>(lessons, [accessDecorator(permissions) as FieldDecorator<Lesson>])
     )
     .mapAsync((lessons) => decorateNavigateTo(lessons) as Promise<Lesson[]>)
-
-  return decorated.recover([])
+    .recover([])
 }
 
 export async function fetchWithACustomDecorator(brand: string) {
@@ -155,9 +154,9 @@ export async function fetchWithACustomDecorator(brand: string) {
     compute: (lesson) => lesson.permission_id === undefined,
   }
 
-  const result = await groq().and(f.brand(brand)).run<Lesson[]>()
+  const result = await groq<Lesson[]>().and(f.brand(brand)).default([]).run()
 
-  return result.map((lessons) => decorateAll<Lesson>(lessons ?? [], [isFree])).recover([])
+  return result.map((lessons) => decorateAll<Lesson>(lessons, [isFree])).recover([])
 }
 
 export async function fetchWhenPermissionsMayBeUnavailable(brand: string) {
@@ -167,7 +166,7 @@ export async function fetchWhenPermissionsMayBeUnavailable(brand: string) {
     )
 
   const [result, permissions] = await Promise.all([
-    groq().and(f.brand(brand)).run<Lesson[]>(),
+    groq<Lesson[]>().and(f.brand(brand)).default([]).run(),
     fetchUserPermissions()
       .then(Either.right<SanityQueryError, UserPermissions>)
       .catch(queryError),
@@ -176,7 +175,7 @@ export async function fetchWhenPermissionsMayBeUnavailable(brand: string) {
   return result
     .flatMap((lessons) =>
       permissions.map((userPermissions) =>
-        decorateAll<Lesson>(lessons ?? [], [
+        decorateAll<Lesson>(lessons, [
           accessDecorator(userPermissions) as FieldDecorator<Lesson>,
         ])
       )
@@ -188,17 +187,14 @@ export async function fetchWhenPermissionsMayBeUnavailable(brand: string) {
 }
 
 export async function decorateManuallyForPreciseTypes(brand: string) {
-  const [result, permissions] = await Promise.all([
-    groq().and(f.brand(brand)).slice(0, 10).run<Lesson[]>(),
-    fetchUserPermissions(),
-  ])
+  const lessons = groq<Lesson[]>().and(f.brand(brand)).slice(0, 10).default([]).run()
+  const permissions = await fetchUserPermissions()
 
-  const decorated = await result
-    .map((lessons) => decorateAccess(lessons ?? [], permissions))
+  return lessons
+    .map((lessons) => decorateAccess(lessons, permissions))
     .mapAsync((lessons) => decorateNavigateTo(lessons))
-
-  return decorated.fold(
-    () => [],
-    (lessons) => lessons.map((lesson) => [lesson.need_access, lesson.navigateTo] as const)
-  )
+    .fold(
+      () => [],
+      (lessons) => lessons.map((lesson) => [lesson.need_access, lesson.navigateTo] as const)
+    )
 }