feat: reimplement model switchRouteSet to perform operation on context to simplify persistence and future access of studio

Author: Julusian

packages/corelib/src/overrideOpHelper.ts

@@ -162,12 +162,15 @@ export interface OverrideOpHelperBatcher extends OverrideOpHelperForItemContents
 export type OverrideOpHelper = () => OverrideOpHelperBatcher
 
 export class OverrideOpHelperImpl implements OverrideOpHelperBatcher {
-	readonly #saveOverrides: SaveOverridesFunction
+	readonly #saveOverrides: SaveOverridesFunction | null
 	readonly #object: ObjectWithOverrides<any>
 
-	constructor(saveOverrides: SaveOverridesFunction, object: ObjectWithOverrides<any>) {
+	constructor(
+		saveOverrides: SaveOverridesFunction | null,
+		object: ObjectWithOverrides<any> | ReadonlyDeep<ObjectWithOverrides<any>>
+	) {
 		this.#saveOverrides = saveOverrides
-		this.#object = { ...object }
+		this.#object = { defaults: object.defaults, overrides: [...object.overrides] }
 	}
 
 	clearItemOverrides = (itemId: string, subPath: string): this => {
@@ -314,6 +317,12 @@ export class OverrideOpHelperImpl implements OverrideOpHelperBatcher {
 	}
 
 	commit = (): void => {
+		if (!this.#saveOverrides) throw new Error('Cannot commit changes without a save function')
+
 		this.#saveOverrides(this.#object.overrides)
 	}
+
+	getPendingOps = (): SomeObjectOverrideOp[] => {
+		return this.#object.overrides
+	}
 }

packages/job-worker/src/__mocks__/context.ts

@@ -226,6 +226,18 @@ export class MockJobContext implements JobContext {
 		// throw new Error('Method not implemented.')
 	}
 
+	setRouteSetActive(_routeSetId: string, _isActive: boolean | 'toggle'): boolean {
+		throw new Error('Method not implemented.')
+	}
+
+	async saveRouteSetChanges(): Promise<void> {
+		// throw new Error('Method not implemented.')
+	}
+
+	discardRouteSetChanges(): void {
+		// throw new Error('Method not implemented.')
+	}
+
 	/**
 	 * Mock methods
 	 */

packages/job-worker/src/jobs/index.ts

@@ -64,6 +64,26 @@ export interface JobContext extends StudioCacheContext {
 
 	/** Hack: fast-track the timeline out to the playout-gateway. */
 	hackPublishTimelineToFastTrack(newTimeline: TimelineComplete): void
+
+	/**
+	 * Set whether a routeset for this studio is active.
+	 * Any routeset `exclusivityGroup` will be respected.
+	 * The changes will be immediately visible in subsequent calls to the `studio` getter
+	 * @param routeSetId The routeSetId to change
+	 * @param isActive Whether the routeSet should be active, or toggle
+	 * @returns Whether the change could affect playout
+	 */
+	setRouteSetActive(routeSetId: string, isActive: boolean | 'toggle'): boolean
+
+	/**
+	 * Save any changes to the routesets for this studio to the database
+	 */
+	saveRouteSetChanges(): Promise<void>
+
+	/**
+	 * Discard any unsaved changes to the routesets for this studio
+	 */
+	discardRouteSetChanges(): void
 }
 
 /**

packages/job-worker/src/playout/model/implementation/PlayoutModelImpl.ts

@@ -481,7 +481,7 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 	}
 
 	switchRouteSet(routeSetId: string, isActive: boolean | 'toggle'): boolean {
-		return this.#baselineHelper.updateRouteSetActive(routeSetId, isActive)
+		return this.context.setRouteSetActive(routeSetId, isActive)
 	}
 
 	cycleSelectedPartInstances(): void {
@@ -635,6 +635,7 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 			...writePartInstancesAndPieceInstances(this.context, this.allPartInstances),
 			writeAdlibTestingSegments(this.context, this.rundownsImpl),
 			this.#baselineHelper.saveAllToDatabase(),
+			this.context.saveRouteSetChanges(),
 		])
 
 		this.#playlistHasChanged = false

packages/job-worker/src/studio/model/StudioBaselineHelper.ts

@@ -6,33 +6,19 @@ import {
 } from '@sofie-automation/corelib/dist/dataModel/ExpectedPackages'
 import { ExpectedPlayoutItemStudio } from '@sofie-automation/corelib/dist/dataModel/ExpectedPlayoutItem'
 import { saveIntoDb } from '../../db/changes'
-import { StudioRouteBehavior, StudioRouteSet } from '@sofie-automation/corelib/dist/dataModel/Studio'
-import { logger } from '../../logging'
-import {
-	WrappedOverridableItemNormal,
-	getAllCurrentItemsFromOverrides,
-	OverrideOpHelperImpl,
-} from '@sofie-automation/corelib/dist/overrideOpHelper'
-import { ObjectWithOverrides, SomeObjectOverrideOp } from '@sofie-automation/corelib/dist/settings/objectWithOverrides'
 
 export class StudioBaselineHelper {
 	readonly #context: JobContext
 
-	#overridesRouteSetBuffer: ObjectWithOverrides<Record<string, StudioRouteSet>>
 	#pendingExpectedPackages: ExpectedPackageDBFromStudioBaselineObjects[] | undefined
 	#pendingExpectedPlayoutItems: ExpectedPlayoutItemStudio[] | undefined
-	#routeSetChanged: boolean
 
 	constructor(context: JobContext) {
 		this.#context = context
-		this.#overridesRouteSetBuffer = { ...context.studio.routeSetsWithOverrides } as ObjectWithOverrides<
-			Record<string, StudioRouteSet>
-		>
-		this.#routeSetChanged = false
 	}
 
 	hasChanges(): boolean {
-		return !!this.#pendingExpectedPackages || !!this.#pendingExpectedPlayoutItems || this.#routeSetChanged
+		return !!this.#pendingExpectedPackages || !!this.#pendingExpectedPlayoutItems
 	}
 
 	setExpectedPackages(packages: ExpectedPackageDBFromStudioBaselineObjects[]): void {
@@ -63,74 +49,9 @@ export class StudioBaselineHelper {
 						this.#pendingExpectedPackages
 				  )
 				: undefined,
-			this.#routeSetChanged
-				? this.#context.directCollections.Studios.update(
-						{
-							_id: this.#context.studioId,
-						},
-						{
-							$set: { 'routeSetsWithOverrides.overrides': this.#overridesRouteSetBuffer.overrides },
-						}
-				  )
-				: undefined,
 		])
 
 		this.#pendingExpectedPlayoutItems = undefined
 		this.#pendingExpectedPackages = undefined
-		this.#routeSetChanged = false
-		this.#overridesRouteSetBuffer = { ...this.#context.studio.routeSetsWithOverrides } as ObjectWithOverrides<
-			Record<string, StudioRouteSet>
-		>
-	}
-
-	updateRouteSetActive(routeSetId: string, isActive: boolean | 'toggle'): boolean {
-		const studio = this.#context.studio
-
-		const routeSets: WrappedOverridableItemNormal<StudioRouteSet>[] = getAllCurrentItemsFromOverrides(
-			this.#overridesRouteSetBuffer,
-			null
-		)
-
-		const routeSet = routeSets.find((routeSet) => routeSet.id === routeSetId)
-
-		if (routeSet === undefined) throw new Error(`RouteSet "${routeSetId}" not found!`)
-
-		if (isActive === 'toggle') isActive = !routeSet.computed.active
-
-		if (routeSet.computed?.behavior === StudioRouteBehavior.ACTIVATE_ONLY && isActive === false)
-			throw new Error(`RouteSet "${routeSet.id}" is ACTIVATE_ONLY`)
-
-		const saveOverrides = (newOps: SomeObjectOverrideOp[]) => {
-			this.#overridesRouteSetBuffer.overrides = newOps
-			this.#routeSetChanged = true
-		}
-		const overrideHelper = new OverrideOpHelperImpl(saveOverrides, this.#overridesRouteSetBuffer)
-
-		// Track whether changing this routeset could affect how the timeline is generated, so that it can be following this update
-		let mayAffectTimeline = couldRoutesetAffectTimelineGeneration(routeSet)
-
-		logger.debug(`switchRouteSet "${studio._id}" "${routeSet.id}"=${isActive}`)
-		overrideHelper.setItemValue(routeSet.id, `active`, isActive)
-
-		// Deactivate other routeSets in the same exclusivity group:
-		if (routeSet.computed.exclusivityGroup && isActive === true) {
-			for (const [, otherRouteSet] of Object.entries<WrappedOverridableItemNormal<StudioRouteSet>>(routeSets)) {
-				if (otherRouteSet.id === routeSet.id) continue
-				if (otherRouteSet.computed?.exclusivityGroup === routeSet.computed.exclusivityGroup) {
-					logger.debug(`switchRouteSet Other ID "${studio._id}" "${otherRouteSet.id}"=false`)
-					overrideHelper.setItemValue(otherRouteSet.id, `active`, false)
-
-					mayAffectTimeline = mayAffectTimeline || couldRoutesetAffectTimelineGeneration(otherRouteSet)
-				}
-			}
-		}
-
-		overrideHelper.commit()
-
-		return mayAffectTimeline
 	}
 }
-
-function couldRoutesetAffectTimelineGeneration(routeSet: WrappedOverridableItemNormal<StudioRouteSet>): boolean {
-	return routeSet.computed.abPlayers.length > 0
-}

packages/job-worker/src/studio/model/StudioPlayoutModelImpl.ts

@@ -102,7 +102,7 @@ export class StudioPlayoutModelImpl implements StudioPlayoutModel {
 	}
 
 	switchRouteSet(routeSetId: string, isActive: boolean | 'toggle'): boolean {
-		return this.#baselineHelper.updateRouteSetActive(routeSetId, isActive)
+		return this.context.setRouteSetActive(routeSetId, isActive)
 	}
 
 	/**
@@ -125,7 +125,11 @@ export class StudioPlayoutModelImpl implements StudioPlayoutModel {
 		}
 		this.#timelineHasChanged = false
 
-		await this.#baselineHelper.saveAllToDatabase()
+		await Promise.all([
+			this.#baselineHelper.saveAllToDatabase(),
+			this.context.saveRouteSetChanges(),
+			//
+		])
 
 		if (span) span.end()
 	}

packages/job-worker/src/workers/context/JobContextImpl.ts

@@ -18,11 +18,16 @@ import { TimelineComplete } from '@sofie-automation/corelib/dist/dataModel/Timel
 import type { QueueJobFunc } from './util'
 import { StudioCacheContextImpl } from './StudioCacheContextImpl'
 import { PlaylistLockImpl, RundownLockImpl } from './Locks'
+import { StudioRouteSetUpdater } from './StudioRouteSetUpdater'
+import type { DBStudio } from '@sofie-automation/corelib/dist/dataModel/Studio'
+import type { ReadonlyDeep } from 'type-fest'
 
 export class JobContextImpl extends StudioCacheContextImpl implements JobContext {
 	private readonly locks: Array<LockBase> = []
 	private readonly caches: Array<BaseModel> = []
 
+	private readonly studioRouteSetUpdater: StudioRouteSetUpdater
+
 	constructor(
 		directCollections: Readonly<IDirectCollections>,
 		cacheData: WorkerDataCache,
@@ -32,6 +37,12 @@ export class JobContextImpl extends StudioCacheContextImpl implements JobContext
 		private readonly fastTrackTimeline: FastTrackTimelineFunc | null
 	) {
 		super(directCollections, cacheData)
+
+		this.studioRouteSetUpdater = new StudioRouteSetUpdater(directCollections, cacheData)
+	}
+
+	get studio(): ReadonlyDeep<DBStudio> {
+		return this.studioRouteSetUpdater.studioWithChanges ?? super.studio
 	}
 
 	trackCache(cache: BaseModel): void {
@@ -138,4 +149,16 @@ export class JobContextImpl extends StudioCacheContextImpl implements JobContext
 			})
 		}
 	}
+
+	setRouteSetActive(routeSetId: string, isActive: boolean | 'toggle'): boolean {
+		return this.studioRouteSetUpdater.setRouteSetActive(routeSetId, isActive)
+	}
+
+	async saveRouteSetChanges(): Promise<void> {
+		return this.studioRouteSetUpdater.saveRouteSetChanges()
+	}
+
+	discardRouteSetChanges(): void {
+		return this.studioRouteSetUpdater.discardRouteSetChanges()
+	}
 }

packages/job-worker/src/workers/context/StudioRouteSetUpdater.ts

@@ -0,0 +1,109 @@
+import { StudioRouteBehavior, StudioRouteSet } from '@sofie-automation/blueprints-integration'
+import type { DBStudio } from '@sofie-automation/corelib/dist/dataModel/Studio'
+import { deepFreeze } from '@sofie-automation/corelib/dist/lib'
+import {
+	getAllCurrentItemsFromOverrides,
+	OverrideOpHelperImpl,
+	WrappedOverridableItemNormal,
+} from '@sofie-automation/corelib/dist/overrideOpHelper'
+import { logger } from '../../logging'
+import type { ReadonlyDeep } from 'type-fest'
+import type { WorkerDataCache } from '../caches'
+import type { IDirectCollections } from '../../db'
+
+export class StudioRouteSetUpdater {
+	readonly #directCollections: Readonly<IDirectCollections>
+	readonly #cacheData: Pick<WorkerDataCache, 'studio'>
+
+	constructor(directCollections: Readonly<IDirectCollections>, cacheData: Pick<WorkerDataCache, 'studio'>) {
+		this.#directCollections = directCollections
+		this.#cacheData = cacheData
+	}
+
+	// Future: this could store a Map<string, boolean>, if the context exposed a simplified view of DBStudio
+	#studioWithRouteSetChanges: ReadonlyDeep<DBStudio> | undefined = undefined
+
+	get studioWithChanges(): ReadonlyDeep<DBStudio> | undefined {
+		return this.#studioWithRouteSetChanges
+	}
+
+	setRouteSetActive(routeSetId: string, isActive: boolean | 'toggle'): boolean {
+		const currentStudio = this.#studioWithRouteSetChanges ?? this.#cacheData.studio
+		const currentRouteSets = getAllCurrentItemsFromOverrides(currentStudio.routeSetsWithOverrides, null)
+
+		const routeSet = currentRouteSets.find((routeSet) => routeSet.id === routeSetId)
+		if (!routeSet) throw new Error(`RouteSet "${routeSetId}" not found!`)
+
+		if (isActive === 'toggle') {
+			isActive = !routeSet.computed.active
+		}
+
+		if (routeSet.computed.behavior === StudioRouteBehavior.ACTIVATE_ONLY && !isActive)
+			throw new Error(`RouteSet "${routeSet.id}" is ACTIVATE_ONLY`)
+
+		const overrideHelper = new OverrideOpHelperImpl(null, currentStudio.routeSetsWithOverrides)
+
+		// Update the pending changes
+		logger.debug(`switchRouteSet "${this.#cacheData.studio._id}" "${routeSet.id}"=${isActive}`)
+		overrideHelper.setItemValue(routeSetId, 'active', isActive)
+
+		let mayAffectTimeline = couldRoutesetAffectTimelineGeneration(routeSet)
+
+		// Deactivate other routeSets in the same exclusivity group:
+		if (routeSet.computed.exclusivityGroup && isActive) {
+			for (const otherRouteSet of Object.values<WrappedOverridableItemNormal<StudioRouteSet>>(currentRouteSets)) {
+				if (otherRouteSet.id === routeSet.id) continue
+				if (otherRouteSet.computed?.exclusivityGroup === routeSet.computed.exclusivityGroup) {
+					logger.debug(`switchRouteSet Other ID "${this.#cacheData.studio._id}" "${otherRouteSet.id}"=false`)
+					overrideHelper.setItemValue(otherRouteSet.id, 'active', false)
+
+					mayAffectTimeline = mayAffectTimeline || couldRoutesetAffectTimelineGeneration(otherRouteSet)
+				}
+			}
+		}
+
+		const updatedOverrideOps = overrideHelper.getPendingOps()
+
+		// Update the cached studio
+		this.#studioWithRouteSetChanges = Object.freeze({
+			...currentStudio,
+			routeSetsWithOverrides: Object.freeze({
+				...currentStudio.routeSetsWithOverrides,
+				overrides: deepFreeze(updatedOverrideOps),
+			}),
+		})
+
+		return mayAffectTimeline
+	}
+
+	async saveRouteSetChanges(): Promise<void> {
+		if (!this.#studioWithRouteSetChanges) return
+
+		// Save the changes to the database
+		// This is technically a little bit of a race condition, if someone uses the config pages but no more so than the rest of the system
+		await this.#directCollections.Studios.update(
+			{
+				_id: this.#cacheData.studio._id,
+			},
+			{
+				$set: {
+					'routeSetsWithOverrides.overrides':
+						this.#studioWithRouteSetChanges.routeSetsWithOverrides.overrides,
+				},
+			}
+		)
+
+		// Pretend that the studio as reported by the database has changed, this will be fixed after this job by the ChangeStream firing
+		this.#cacheData.studio = this.#studioWithRouteSetChanges
+		this.#studioWithRouteSetChanges = undefined
+	}
+
+	discardRouteSetChanges(): void {
+		// Discard any pending changes
+		this.#studioWithRouteSetChanges = undefined
+	}
+}
+
+function couldRoutesetAffectTimelineGeneration(routeSet: WrappedOverridableItemNormal<StudioRouteSet>): boolean {
+	return routeSet.computed.abPlayers.length > 0
+}