musora-content-services 2.178.0 → 2.179.0

package/.agent/decisions/2026-05-20-content-progress-ts-part-5.md

@@ -0,0 +1,39 @@
+---
+date: 2026-05-20
+branch: refactor/content-progress-ts-part-5
+pr: https://github.com/railroadmedia/musora-content-services/pull/981
+status: open
+tags: [[chore]]
+related: [[2026-05-19-content-progress-ts-part-2]]
+---
+
+# Extract progress mutations and learning-path duplication guard
+
+## Context
+
+With the read path (`state.ts`, `collections.ts`), shared types, bubble/trickle logic (`internal/bubble.ts`), and query helpers (`internal/queries.ts`) already extracted in earlier parts of the refactor, the write path remained in the legacy `contentProgress.js`. All mutation operations (`save`, `setStatus`, `setStatusMany`, `markCompleted`, `markStarted`, `reset`) needed to move into the typed `progress/` module to complete the decomposition and enable direct test coverage.
+
+## Decision
+
+Introduced two new files:
+
+- `src/services/progress/mutations.ts` — owns all write operations. `save` handles offline/online paths, filters negative-progress writes, computes bubble/trickle, and delegates LP completion actions. `setStatus`/`setStatusMany`/`reset` follow the same shape. Public `mark*` aliases provide a stable call surface. A private `requestPush` helper centralises the skipPush guard pattern.
+- `src/services/progress/internal/learning-path.ts` — extracts `filterOutLearningPathsForDuplication`, the rule that prevents the LP root record from being written back as an a-la-carte record. Isolating it makes the invariant visible and independently testable.
+
+Test coverage added:
+- `test/integration/progress/mutations.test.ts` — integration tests against the in-memory WatermelonDB harness covering all public mutation functions and key scenarios (higher/lower/equal progress, skipBubbleTrickle, etc.)
+- `test/unit/services/progress-internal/learning-path.test.ts` — unit tests for the LP duplication filter covering non-LP passthrough, LP root exclusion, and string-key coercion
+
+## Alternatives Considered
+
+Keeping mutations in `contentProgress.js` until the full JS→TS migration is complete was considered but rejected. The write path is high-risk and untested; extracting it into TypeScript now lets us add direct coverage and enforce types on the critical save/bubble interaction.
+
+## Process Notes
+
+`filterOutLearningPathsForDuplication` uses `Number(id)` on string keys from `Object.entries` to match the numeric `collection.id`. A dedicated unit test documents and guards this coercion.
+
+## Consequences
+
+- `Progress.*` namespace now covers both the read and write path; callers can import from `src/services/progress` for all operations
+- The write path has direct integration test coverage for the first time
+- `contentProgress.js` mutation functions can be deprecated and removed in a follow-up once consumers are migrated

package/.agent/decisions/2026-08-28-mu2-1877-marketing-sanity-queries.md

@@ -0,0 +1,38 @@
+---
+date: 2026-08-28
+branch: feat/marketing-sanity-queries
+pr: https://github.com/railroadmedia/musora-content-services/pull/1040
+status: open
+tags: [[feature]]
+related: [[2026-07-20-query-builder-tostring]]
+---
+
+# Marketing workspace Sanity types and query functions
+
+## Context
+The new marketing workspace in Sanity introduced four document types — `stats`, `practice-goal`, `testimonial` and `faq` — with no typed access from MCS. Consumers would otherwise hand-write both the GROQ and the result shapes, which drift as the schema changes.
+
+## Decision
+Two pieces:
+
+- `tools/generate-sanity-types.cjs` (exposed as `npm run gen-sanity-types`) derives TypeScript declarations from the musora-platform-backend Sanity schema into `src/lib/sanity/types/marketing.d.ts`. Generated, not hand-maintained, so schema changes are picked up by re-running the generator. Covered by `test/unit/generateSanityTypes.test.js`.
+- `src/services/marketing/marketing.ts` exposes `fetchMarketingStats`, `fetchMarketingPracticeGoals`, `fetchMarketingTestimonials` and `fetchMarketingFaqs`, built on the newer `groq`/`query`/`filter` helpers in `src/lib/sanity/` rather than the legacy query strings in `sanity.js`.
+
+All four documents are singletons per brand, so a single private `fetchBrandDocument<T>(type, brand)` helper applies `Filters.combine(Filters.type(type), Filters.brand(brand))`, takes `.first()`, and collapses the `Either` with `.recover(null)`. Each public function is a one-line wrapper that pins the generated type. `fetchMarketingFaqs` additionally takes `includeWebOnly = true`; when false it filters out questions flagged `web_only`, for mobile callers.
+
+No field projections — the queries return the whole document, which is exactly what the generated types describe.
+
+## Alternatives Considered
+- One file per document type under `src/services/marketing/`. Rejected: four near-identical three-line functions, single file is smaller and easier to read.
+- Explicit `select(...)` projections per document. Rejected: these documents are small and the generated type already covers every field; projections would need updating on every schema change for no measurable gain.
+- Hand-written type declarations. Rejected: guaranteed to drift from the backend schema.
+
+## Process Notes
+- The generated `StatsDocument` is a discriminated union on `brand` — `musora` carries `total_student_count`, the instrument brands carry `learning_paths_count` and `artist_courses_count`. Callers must narrow on `brand` before reaching for those fields.
+- `run<T>()` already returns `T | null` for a query that matched nothing; `.recover(null)` only handles the `Left` (query error) case.
+- `src/index.js` / `src/index.d.ts` are generated by `npm run build-index` and were regenerated in this branch to export the four new functions.
+
+## Consequences
+- Marketing document access is typed and centralised; new marketing document types follow the same pattern.
+- The generated types must be refreshed with `npm run gen-sanity-types` whenever the backend marketing schema changes — a stale `marketing.d.ts` will typecheck fine while being wrong.
+- No new runtime dependencies.

package/.claude/settings.local.json

@@ -0,0 +1,71 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx jest *)",
+      "Bash(npx tsc *)",
+      "Skill(counselors)",
+      "Bash(counselors ls *)",
+      "Bash(counselors groups *)",
+      "Bash(counselors run *)",
+      "Bash(npm test *)",
+      "Bash(gh pr *)",
+      "Bash(gh api *)",
+      "Bash(mkdir -p /tmp/pr-review-v2)",
+      "Read(//tmp/pr-review-v2/**)",
+      "Bash(cat /home/alesevero/railenvironment/applications/musora-content-services/AGENTS.md)",
+      "Bash(echo \"no AGENTS.md\")",
+      "Bash(echo \"exit=$?\")",
+      "Bash(git checkout *)",
+      "Skill(pr)",
+      "Skill(create-decision)",
+      "mcp__github__pull_request_read",
+      "mcp__github__push_files",
+      "Bash(git push *)",
+      "mcp__github__create_pull_request",
+      "mcp__github__search_pull_requests",
+      "Bash(git commit *)",
+      "Bash(git add *)",
+      "mcp__github__list_pull_requests",
+      "mcp__sanity__get_schema",
+      "mcp__sanity__query_documents",
+      "Bash(git rm *)",
+      "Bash(git rebase *)",
+      "Bash(git fetch *)",
+      "Bash(git --no-pager log --oneline -1)",
+      "Bash(git --no-pager log --oneline -5)",
+      "Bash(git ls-tree *)",
+      "Bash(git --no-pager log --oneline -2)",
+      "Bash(git --no-pager diff --stat HEAD~1)",
+      "Bash(git check-ignore *)",
+      "Bash(python3 -)",
+      "Bash(git --no-pager log --oneline -3)",
+      "Bash(mkdir *)",
+      "Bash(git --no-pager log --oneline origin/main..HEAD)"
+    ]
+  },
+  "model": "sonnet",
+  "enabledMcpjsonServers": [
+    "atlassian",
+    "figma",
+    "google-workspace",
+    "snowflake",
+    "aws",
+    "hex",
+    "sanity",
+    "mysql",
+    "slack",
+    "langfuse",
+    "chrome-devtools",
+    "railway",
+    "github",
+    "asana"
+  ],
+  "disabledMcpjsonServers": [
+    "nightwatch",
+    "1password",
+    "mysql-staging",
+    "mysql-local",
+    "mobile"
+  ],
+  "effortLevel": "medium"
+}

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 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.179.0](https://github.com/railroadmedia/musora-content-services/compare/v2.178.1...v2.179.0) (2026-09-03)
+
+
+### Features
+
+* **MU2-1877:** Add Sanity type generation and marketing query functions ([#1040](https://github.com/railroadmedia/musora-content-services/issues/1040)) ([a232299](https://github.com/railroadmedia/musora-content-services/commit/a232299286ce22fa04591a812c65039544682e37))
+
+
+### Bug Fixes
+
+* **BR-725:** fetch tab data with progress applied ([#1044](https://github.com/railroadmedia/musora-content-services/issues/1044)) ([d19baf1](https://github.com/railroadmedia/musora-content-services/commit/d19baf1565d54a5e6179b6ae21b184ceb64c8aee))
+
+### [2.178.1](https://github.com/railroadmedia/musora-content-services/compare/v2.178.0...v2.178.1) (2026-08-31)
+
 ## [2.178.0](https://github.com/railroadmedia/musora-content-services/compare/v2.177.1...v2.178.0) (2026-08-28)
 
 

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "musora-content-services",
-  "version": "2.178.0",
+  "version": "2.179.0",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "type": "module",
   "scripts": {
     "prepare": "node scripts/gen-version.cjs",
     "build-index": "node tools/generate-index.cjs",
+    "gen-sanity-types": "node tools/generate-sanity-types.cjs",
     "release": "standard-version",
     "doc": "jsdoc -c jsdoc.json --verbose",
     "test": "jest",

package/src/index.d.ts

@@ -224,6 +224,14 @@ import {
 	createTestUser
 } from './services/liveTesting.ts';
 
+import {
+	fetchMarketingAll,
+	fetchMarketingFaqs,
+	fetchMarketingPracticeGoals,
+	fetchMarketingStats,
+	fetchMarketingTestimonials
+} from './services/marketing/marketing.ts';
+
 import {
 	acceptInvite,
 	createAccount,
@@ -654,6 +662,11 @@ declare module 'musora-content-services' {
 		fetchLiveEvent,
 		fetchLiveEventPollingState,
 		fetchLiveStreamData,
+		fetchMarketingAll,
+		fetchMarketingFaqs,
+		fetchMarketingPracticeGoals,
+		fetchMarketingStats,
+		fetchMarketingTestimonials,
 		fetchMemberships,
 		fetchMetadata,
 		fetchMethodV2IntroVideo,

package/src/index.js

@@ -228,6 +228,14 @@ import {
 	createTestUser
 } from './services/liveTesting.ts';
 
+import {
+	fetchMarketingAll,
+	fetchMarketingFaqs,
+	fetchMarketingPracticeGoals,
+	fetchMarketingStats,
+	fetchMarketingTestimonials
+} from './services/marketing/marketing.ts';
+
 import {
 	acceptInvite,
 	createAccount,
@@ -653,6 +661,11 @@ export {
 	fetchLiveEvent,
 	fetchLiveEventPollingState,
 	fetchLiveStreamData,
+	fetchMarketingAll,
+	fetchMarketingFaqs,
+	fetchMarketingPracticeGoals,
+	fetchMarketingStats,
+	fetchMarketingTestimonials,
 	fetchMemberships,
 	fetchMetadata,
 	fetchMethodV2IntroVideo,

package/src/lib/ads/coproduct.ts

@@ -4,7 +4,14 @@ import { Recoverable } from './interfaces/recoverable'
 import { Tappable } from './interfaces/tappable'
 import { Monad } from './monad'
 
-/** A monadic container that represents a value that can be either a left or a right value. */
+/**
+ * A monadic container holding either a left value (`L`, usually an error/failure) or a right
+ * value (`R`, usually a success). Convention: right is the "happy path" that `map`/`flatMap`
+ * operate on; left short-circuits those and passes through unchanged.
+ * @example
+ * Coproduct.right(5).map(n => n + 1)          // Right(6)
+ * Coproduct.left('err').map((n: number) => n) // Left('err'), fn never called
+ */
 export abstract class Coproduct<L, R>
   implements
     Tappable<L | R>,
@@ -13,40 +20,71 @@ export abstract class Coproduct<L, R>
     Recoverable<R>,
     Monad<L | R>
 {
+  /** @param value - the left value to wrap */
   static left<L, R>(value: L): Coproduct<L, R> {
     return new Left(value)
   }
 
+  /** @param value - the right value to wrap */
   static right<L, R>(value: R): Coproduct<L, R> {
     return new Right(value)
   }
 
+  /** Type guard: true if this is a {@link Left}. */
   abstract isLeft(): this is Left<L, R>
+  /** Type guard: true if this is a {@link Right}. */
   abstract isRight(): this is Right<L, R>
 
   /**
    * @extends Functor
    * Maps the right value of the Coproduct.
+   * @example
+   * Coproduct.right(2).map(n => n * 2) // Right(4)
+   * Coproduct.left('err').map(n => n)  // Left('err'), fn never called
    */
   abstract map<T>(fn: (r: R) => T): Coproduct<L, T>
+
   /**
    * Maps the right value of the Coproduct with an asynchronous function.
    * A rejection propagates: there is no way to build an L from it.
+   * @example
+   * await Coproduct.right(userId).mapAsync(id => fetchUser(id)) // Right(user)
    */
   abstract mapAsync<T>(fn: (r: R) => Promise<T>): Promise<Coproduct<L, T>>
+
   /**
    * @extends Monad
-   * Applies a function to the right value of the Coproduct, returning a new Coproduct.
+   * Like {@link map}, but `fn` itself returns a Coproduct instead of a plain value, so nested
+   * Coproducts get flattened. No-op on Left.
+   * @example
+   * Coproduct.right(id).flatMap(id => validate(id)) // validate returns a Coproduct itself
    */
   abstract flatMap<T>(fn: (r: R) => Coproduct<L, T>): Coproduct<L, T>
 
-  /** Maps the left value of the Coproduct to a new type. */
-  abstract mapLeft<T>(fn: (l: L) => T): Coproduct<T, R>
+  /**
+   * Maps the left value of the Coproduct to a new type. No-op on Right.
+   * @example
+   * Coproduct.left(new Error('bad')).lmap(e => e.message) // Left('bad')
+   */
+  abstract lmap<T>(fn: (l: L) => T): Coproduct<T, R>
 
-  /** Applies a function to the left value of the Coproduct, returning a new Coproduct. */
-  abstract flatMapLeft<T>(fn: (l: L) => Coproduct<T, R>): Coproduct<T, R>
+  /**
+   * Left-side equivalent of {@link flatMap}: `fn` returns a Coproduct, flattening nested
+   * results. No-op on Right.
+   */
+  abstract lflatMap<T>(fn: (l: L) => Coproduct<T, R>): Coproduct<T, R>
 
+  /**
+   * Unwraps the Coproduct by calling whichever handler matches its side.
+   * @example
+   * result.fold(
+   *   err => showError(err),
+   *   value => showValue(value)
+   * )
+   */
   abstract fold<T, U>(onLeft: (l: L) => T, onRight: (r: R) => U): T | U
+
+  /** 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(
       (l) => fn(initial, l),
@@ -57,19 +95,28 @@ export abstract class Coproduct<L, R>
   /**
    * Visits the value inside the container if right and applies a function to it without modifying
    * @implements Tappable
+   * @example
+   * Coproduct.right(user).tap(u => console.log('loaded', u.id)) // logs, still Right(user)
    */
   abstract tap(fn: (r: R) => void): this
 
   /** Visits the value inside the container if left and applies a function to it without modifying */
   abstract ltap(fn: (l: L) => void): Coproduct<L, R>
+
+  /** Unwraps the Coproduct, returning whichever value it holds (left or right) untouched. */
   abstract drop(): R | L
+
   /**
    * Returns the right value if it exists, otherwise returns the provided default value.
    * @implements Recoverable
+   * @example
+   * Coproduct.left('err').recover(0) // 0
+   * Coproduct.right(5).recover(0)    // 5
    */
   abstract recover(defaultValue: R): R
 }
 
+/** A left value in a Coproduct, usually representing a failure or invalid result. */
 export class Left<L, R> extends Coproduct<L, R> {
   constructor(private readonly value: L) {
     super()
@@ -95,11 +142,11 @@ export class Left<L, R> extends Coproduct<L, R> {
     return new Left(this.value)
   }
 
-  mapLeft<T>(fn: (l: L) => T): Coproduct<T, R> {
+  lmap<T>(fn: (l: L) => T): Coproduct<T, R> {
     return new Left(fn(this.value))
   }
 
-  flatMapLeft<T>(fn: (l: L) => Coproduct<T, R>): Coproduct<T, R> {
+  lflatMap<T>(fn: (l: L) => Coproduct<T, R>): Coproduct<T, R> {
     return fn(this.value)
   }
 
@@ -152,11 +199,11 @@ export class Right<L, R> extends Coproduct<L, R> {
     return fn(this.value)
   }
 
-  mapLeft<T>(_fn: (l: L) => T): Coproduct<T, R> {
+  lmap<T>(_fn: (l: L) => T): Coproduct<T, R> {
     return new Right(this.value)
   }
 
-  flatMapLeft<T>(_fn: (l: L) => Coproduct<T, R>): Coproduct<T, R> {
+  lflatMap<T>(_fn: (l: L) => Coproduct<T, R>): Coproduct<T, R> {
     return new Right(this.value)
   }
 

package/src/lib/ads/either.ts

@@ -1,6 +1,16 @@
 import { Coproduct } from './coproduct'
 
-/** A Coproduct under the convention that left carries the error and right carries the success value. */
+/**
+ * A {@link Coproduct} under the convention that left carries the error and right carries the
+ * success value.
+ * @example
+ * function parseAge(input: string): Either<string, number> {
+ *   const n = Number(input)
+ *   return Number.isNaN(n) ? Either.left('not a number') : Either.right(n)
+ * }
+ * parseAge('42').map(n => n + 1) // Right(43)
+ * parseAge('x').map(n => n + 1)  // Left('not a number')
+ */
 export type Either<L, R> = Coproduct<L, R>
 
 export const Either = {

package/src/lib/sanity/types/marketing.d.ts

@@ -0,0 +1,94 @@
+// Generated by tools/generate-sanity-types.cjs from the musora-platform-backend Sanity schema.
+// Do not edit by hand; re-run the generator instead.
+export type StatsDocument = {
+  _id: string
+  _type: "stats"
+  _createdAt: string
+  _updatedAt: string
+  _rev: string
+  /** Songs Count */
+  songs_count?: string
+} & (
+  | {
+      brand: "musora"
+      /** Total Student Count */
+      total_student_count?: string
+    }
+  | {
+      brand: "drumeo" | "pianote" | "singeo" | "guitareo" | "playbass"
+      /** Learning Paths Count */
+      learning_paths_count?: string
+      /** Artist Courses Count */
+      artist_courses_count?: string
+    }
+)
+
+export type PracticeGoalDocument = {
+  _id: string
+  _type: "practice-goal"
+  _createdAt: string
+  _updatedAt: string
+  _rev: string
+  brand: "drumeo" | "pianote" | "singeo" | "guitareo" | "playbass"
+  /** <2 Days a Week */
+  under_two_days_a_week?: {
+    /** First Day */
+    first_day?: string
+    /** First Week */
+    first_week?: string
+    /** First Month */
+    first_month?: string
+  }
+  /** 3-4 Days a Week */
+  three_to_four_days_a_week?: {
+    /** First Day */
+    first_day?: string
+    /** First Week */
+    first_week?: string
+    /** First Month */
+    first_month?: string
+  }
+  /** 5+ Days a Week */
+  five_plus_days_a_week?: {
+    /** First Day */
+    first_day?: string
+    /** First Week */
+    first_week?: string
+    /** First Month */
+    first_month?: string
+  }
+}
+
+export type TestimonialDocument = {
+  _id: string
+  _type: "testimonial"
+  _createdAt: string
+  _updatedAt: string
+  _rev: string
+  brand: "musora" | "drumeo" | "pianote" | "singeo" | "guitareo" | "playbass"
+  /** Testimonials */
+  testimonials?: {
+    _key: string
+    name?: string
+    location?: string
+    /** Testimonial Copy */
+    copy?: string
+  }[]
+}
+
+export type FaqDocument = {
+  _id: string
+  _type: "faq"
+  _createdAt: string
+  _updatedAt: string
+  _rev: string
+  brand: "musora" | "drumeo" | "pianote" | "singeo" | "guitareo" | "playbass"
+  /** FAQs */
+  questions?: {
+    _key: string
+    /** Web Only? */
+    web_only?: boolean
+    question?: string
+    answer?: string
+  }[]
+}

package/src/services/marketing/marketing.ts

@@ -0,0 +1,87 @@
+import { Brands } from '../../lib/brands'
+import type { Either } from '../../lib/ads/either'
+import { Filters as f } from '../../lib/sanity/filter'
+import { groq } from '../../lib/sanity/groq'
+import { SanityQueryError } from '../../lib/sanity/runner'
+import type {
+  FaqDocument,
+  PracticeGoalDocument,
+  StatsDocument,
+  TestimonialDocument,
+} from '../../lib/sanity/types/marketing'
+
+const excludeFromGeneratedIndex = [
+  'fetchBrandDocument',
+  'brandDocumentQuery',
+  'faqProjection',
+  'statsProjection',
+]
+
+export function brandDocumentQuery(type: string, brand: Brands | string, projection?: string[]) {
+  const builder = groq()
+    .and(f.combine(f.type(type), f.brand(brand)))
+    .first()
+  return projection ? builder.select(...projection) : builder
+}
+
+const fetchBrandDocument = <T>(type: string, brand: Brands | string, projection?: string[]) =>
+  brandDocumentQuery(type, brand, projection).run<T>()
+
+export function faqProjection(includeWebOnly: boolean): string[] | undefined {
+  return includeWebOnly ? undefined : ['...', 'questions[!web_only]']
+}
+
+export function statsProjection(isMusora: boolean): string[] | undefined {
+  if (isMusora) return undefined
+
+  const musoraFilter = f.combine(f.type('stats'), f.brand(Brands.Musora))
+  return ['...', `"total_student_count": *[${musoraFilter}][0].total_student_count`]
+}
+
+export async function fetchMarketingStats(
+  brand: Brands | string
+): Promise<Either<SanityQueryError, StatsDocument | null>> {
+  return fetchBrandDocument<StatsDocument>('stats', brand)
+}
+
+export async function fetchMarketingPracticeGoals(
+  brand: Brands | string
+): Promise<Either<SanityQueryError, PracticeGoalDocument | null>> {
+  return fetchBrandDocument<PracticeGoalDocument>('practice-goal', brand)
+}
+
+export async function fetchMarketingTestimonials(
+  brand: Brands | string
+): Promise<Either<SanityQueryError, TestimonialDocument | null>> {
+  return fetchBrandDocument<TestimonialDocument>('testimonial', brand)
+}
+
+export async function fetchMarketingFaqs(
+  brand: Brands | string,
+  includeWebOnly: boolean = true
+): Promise<Either<SanityQueryError, FaqDocument | null>> {
+  return fetchBrandDocument<FaqDocument>('faq', brand, faqProjection(includeWebOnly))
+}
+
+export interface MarketingBundle {
+  stats: (StatsDocument & { total_student_count?: string }) | null
+  practiceGoals: PracticeGoalDocument | null
+  testimonials: TestimonialDocument | null
+  faqs: FaqDocument | null
+}
+
+export async function fetchMarketingAll(
+  brand: Brands | string,
+  includeWebOnlyFaqs: boolean = true
+): Promise<Either<SanityQueryError, MarketingBundle>> {
+  const isMusora = brand === Brands.Musora
+
+  return groq
+    .composite({
+      stats: brandDocumentQuery('stats', brand, statsProjection(isMusora)),
+      practiceGoals: brandDocumentQuery('practice-goal', brand),
+      testimonials: brandDocumentQuery('testimonial', brand),
+      faqs: brandDocumentQuery('faq', brand, faqProjection(includeWebOnlyFaqs)),
+    })
+    .run<MarketingBundle>()
+}

package/src/services/progress/collections.ts

@@ -31,3 +31,11 @@ export const allStartedOrCompleted = async (
       updatedAfter: Math.floor(Date.now() / 1000) - SIXTY_DAYS_IN_SECONDS,
     })
     .then((r) => r.data)
+
+export const percentByContentId = async (brand?: string): Promise<Record<number, number>> =>
+  db.contentProgress
+    .startedOrCompleted({
+      brand,
+      updatedAfter: Math.floor(Date.now() / 1000) - SIXTY_DAYS_IN_SECONDS,
+    })
+    .then((r) => Object.fromEntries(r.data.map((p) => [p.content_id, p.progress_percent])))

package/src/services/progress/index.ts

@@ -1,8 +1,9 @@
 import * as state from './state'
 import * as collections from './collections'
 import * as utils from './utils'
+import * as mutations from './mutations'
 
-export const Progress = { ...state, ...collections, ...utils }
+export const Progress = { ...state, ...collections, ...utils, ...mutations }
 
 export type {
   ProgressContentFilter,

package/src/services/progress/internal/bubble.ts

@@ -34,7 +34,10 @@ export const getAncestorAndSiblingIds = (
   const parentId = hierarchy?.parents?.[contentId]
   if (!parentId) return []
 
-  if (parentId === contentId) return []
+  if (parentId === contentId) {
+    console.error('Circular dependency detected for contentId', contentId)
+    return []
+  }
 
   const siblingIds = hierarchy?.children?.[parentId] ?? []
   const allIds = [

package/src/services/progress/internal/learning-path.ts

@@ -0,0 +1,14 @@
+import { COLLECTION_TYPE, CollectionParameter } from '../../sync/models/ContentProgress'
+
+export const filterOutLearningPathsForDuplication = (
+  progresses: Record<number, number>,
+  collection: CollectionParameter
+): Record<number, number> =>
+  Object.fromEntries(
+    Object.entries(progresses).filter(([id]) => {
+      if (collection.type === COLLECTION_TYPE.LEARNING_PATH) {
+        return Number(id) !== collection.id
+      }
+      return true
+    })
+  )

package/src/services/progress/internal/queries.ts

@@ -2,7 +2,7 @@ import { db } from '../../sync'
 import type { ModelSerialized } from '../../sync/serializers'
 import ContentProgress, { CollectionParameter } from '../../sync/models/ContentProgress'
 
-type Selector<V> = (p: ModelSerialized<ContentProgress>) => V
+type Selector<V> = (p: ModelSerialized<ContentProgress>) => V | null | undefined
 
 export const getByIds = async <V>(
   contentIds: number[],
@@ -30,10 +30,14 @@ export const getById = async <V>(
   if (!contentId) return defaultValue
   return db.contentProgress
     .getOneProgressByContentId(contentId, collection)
-    .then((r) => (r.data ? selector(r.data) : defaultValue) ?? defaultValue)
+    .then((r) => (r.data ? selector(r.data) ?? defaultValue : defaultValue))
 }
 
-export const getByRecordIds = async <V>(ids: string[], selector: Selector<V>, defaultValue: V) => {
+export const getByRecordIds = async <V>(
+  ids: string[],
+  selector: Selector<V>,
+  defaultValue: V
+): Promise<Record<string, V>> => {
   const progress = Object.fromEntries(ids.map((id) => [id, defaultValue]))
 
   await db.contentProgress.getSomeProgressByRecordIds(ids).then((r) => {