wip

Author: Julusian

meteor/server/api/deviceTriggers/triggersContext.ts

@@ -14,39 +14,25 @@ import { PartId, StudioId } from '@sofie-automation/corelib/dist/dataModel/Ids'
 import { DummyReactiveVar } from '@sofie-automation/meteor-lib/dist/triggers/reactive-var'
 import { ReactivePlaylistActionContext } from '@sofie-automation/meteor-lib/dist/triggers/actionFactory'
 import { MongoQuery } from '@sofie-automation/corelib/dist/mongo'
-import { CollectionName } from '@sofie-automation/corelib/dist/dataModel/Collections'
-import { AdLibAction } from '@sofie-automation/corelib/dist/dataModel/AdlibAction'
-import { AdLibPiece } from '@sofie-automation/corelib/dist/dataModel/AdLibPiece'
-import { PartInstance } from '@sofie-automation/meteor-lib/dist/collections/PartInstances'
+import { DBRundownPlaylist, SelectedPartInstance } from '@sofie-automation/corelib/dist/dataModel/RundownPlaylist'
+import {
+	AdLibActions,
+	AdLibPieces,
+	PartInstances,
+	Parts,
+	RundownBaselineAdLibActions,
+	RundownBaselineAdLibPieces,
+	RundownPlaylists,
+	Rundowns,
+	Segments,
+} from '../../collections'
 import { DBPart } from '@sofie-automation/corelib/dist/dataModel/Part'
-import { RundownBaselineAdLibAction } from '@sofie-automation/corelib/dist/dataModel/RundownBaselineAdLibAction'
-import { RundownBaselineAdLibItem } from '@sofie-automation/corelib/dist/dataModel/RundownBaselineAdLibPiece'
-import { DBRundownPlaylist } from '@sofie-automation/corelib/dist/dataModel/RundownPlaylist'
-import { DBRundown } from '@sofie-automation/corelib/dist/dataModel/Rundown'
-import { DBSegment } from '@sofie-automation/corelib/dist/dataModel/Segment'
-import { createSyncReadOnlyMongoCollection } from './triggersContextCollection'
+import { DBPartInstance } from '@sofie-automation/corelib/dist/dataModel/PartInstance'
 
 export function hashSingleUseToken(token: string): string {
 	return getHash(SINGLE_USE_TOKEN_SALT + token)
 }
 
-/**
- * Some synchronous read-only collections to satisfy the TriggersContext interface
- */
-const AdLibActions = createSyncReadOnlyMongoCollection<AdLibAction>(CollectionName.AdLibActions)
-const AdLibPieces = createSyncReadOnlyMongoCollection<AdLibPiece>(CollectionName.AdLibPieces)
-const PartInstances = createSyncReadOnlyMongoCollection<PartInstance>(CollectionName.PartInstances)
-const Parts = createSyncReadOnlyMongoCollection<DBPart>(CollectionName.Parts)
-const RundownBaselineAdLibActions = createSyncReadOnlyMongoCollection<RundownBaselineAdLibAction>(
-	CollectionName.RundownBaselineAdLibActions
-)
-const RundownBaselineAdLibPieces = createSyncReadOnlyMongoCollection<RundownBaselineAdLibItem>(
-	CollectionName.RundownBaselineAdLibPieces
-)
-const RundownPlaylists = createSyncReadOnlyMongoCollection<DBRundownPlaylist>(CollectionName.RundownPlaylists)
-const Rundowns = createSyncReadOnlyMongoCollection<DBRundown>(CollectionName.Rundowns)
-const Segments = createSyncReadOnlyMongoCollection<DBSegment>(CollectionName.Segments)
-
 export const MeteorTriggersContext: TriggersContext = {
 	MeteorCall,
 
@@ -83,71 +69,86 @@ export const MeteorTriggersContext: TriggersContext = {
 
 	nonreactiveTracker: Tracker.nonreactive,
 
-	memoizedIsolatedAutorun: <T extends (...args: any) => any>(
-		fnc: T,
+	memoizedIsolatedAutorun: async <TArgs extends any[], TRes>(
+		fnc: (...args: TArgs) => Promise<TRes>,
 		_functionName: string,
-		...params: Parameters<T>
-	): ReturnType<T> => {
-		return fnc(...(params as any))
+		...params: TArgs
+	): Promise<TRes> => {
+		return fnc(...params)
 	},
 
 	createContextForRundownPlaylistChain,
 }
 
-function createContextForRundownPlaylistChain(
+async function createContextForRundownPlaylistChain(
 	studioId: StudioId,
 	filterChain: IBaseFilterLink[]
-): ReactivePlaylistActionContext | undefined {
-	const playlist = rundownPlaylistFilter(
+): Promise<ReactivePlaylistActionContext | undefined> {
+	const playlist = await rundownPlaylistFilter(
 		studioId,
 		filterChain.filter((link) => link.object === 'rundownPlaylist') as IRundownPlaylistFilterLink[]
 	)
 
 	if (!playlist) return undefined
 
-	let currentPartId: PartId | null = null,
-		nextPartId: PartId | null = null,
-		currentPartInstance: PartInstance | null = null,
-		currentSegmentPartIds: PartId[] = [],
-		nextSegmentPartIds: PartId[] = []
-
-	if (playlist.currentPartInfo) {
-		currentPartInstance = PartInstances.findOne(playlist.currentPartInfo.partInstanceId) ?? null
-		const currentPart = currentPartInstance?.part ?? null
-		if (currentPart) {
-			currentPartId = currentPart._id
-			currentSegmentPartIds = Parts.find({
-				segmentId: currentPart.segmentId,
-			}).map((part) => part._id)
-		}
-	}
-	if (playlist.nextPartInfo) {
-		const nextPart = PartInstances.findOne(playlist.nextPartInfo.partInstanceId)?.part ?? null
-		if (nextPart) {
-			nextPartId = nextPart._id
-			nextSegmentPartIds = Parts.find({
-				segmentId: nextPart.segmentId,
-			}).map((part) => part._id)
-		}
-	}
+	const [currentPartInfo, nextPartInfo] = await Promise.all([
+		fetchInfoForSelectedPart(playlist.currentPartInfo),
+		fetchInfoForSelectedPart(playlist.nextPartInfo),
+	])
 
 	return {
 		studioId: new DummyReactiveVar(studioId),
 		rundownPlaylistId: new DummyReactiveVar(playlist?._id),
 		rundownPlaylist: new DummyReactiveVar(playlist),
-		currentRundownId: new DummyReactiveVar(currentPartInstance?.rundownId ?? playlist.rundownIdsInOrder[0] ?? null),
-		currentPartId: new DummyReactiveVar(currentPartId),
-		currentSegmentPartIds: new DummyReactiveVar(currentSegmentPartIds),
-		nextPartId: new DummyReactiveVar(nextPartId),
-		nextSegmentPartIds: new DummyReactiveVar(nextSegmentPartIds),
+		currentRundownId: new DummyReactiveVar(
+			playlist.currentPartInfo?.rundownId ?? playlist.rundownIdsInOrder[0] ?? null
+		),
+		currentPartId: new DummyReactiveVar(currentPartInfo?.partId ?? null),
+		currentSegmentPartIds: new DummyReactiveVar(currentPartInfo?.segmentPartIds ?? []),
+		nextPartId: new DummyReactiveVar(nextPartInfo?.partId ?? null),
+		nextSegmentPartIds: new DummyReactiveVar(nextPartInfo?.segmentPartIds ?? []),
 		currentPartInstanceId: new DummyReactiveVar(playlist.currentPartInfo?.partInstanceId ?? null),
 	}
 }
 
-function rundownPlaylistFilter(
+async function fetchInfoForSelectedPart(partInfo: SelectedPartInstance | null): Promise<{
+	partId: PartId
+	segmentPartIds: PartId[]
+} | null> {
+	if (!partInfo) return null
+
+	const partInstance = (await PartInstances.findOneAsync(partInfo.partInstanceId, {
+		projection: {
+			// @ts-expect-error deep property
+			'part._id': 1,
+			segmentId: 1,
+		},
+	})) as (Pick<DBPartInstance, 'segmentId'> & { part: Pick<DBPart, '_id'> }) | null
+
+	if (!partInstance) return null
+
+	const partId = partInstance.part._id
+	const segmentPartIds = await Parts.findFetchAsync(
+		{
+			segmentId: partInstance.segmentId,
+		},
+		{
+			projection: {
+				_id: 1,
+			},
+		}
+	).then((parts) => parts.map((part) => part._id))
+
+	return {
+		partId,
+		segmentPartIds,
+	}
+}
+
+async function rundownPlaylistFilter(
 	studioId: StudioId,
 	filterChain: IRundownPlaylistFilterLink[]
-): DBRundownPlaylist | undefined {
+): Promise<DBRundownPlaylist | undefined> {
 	const selector: MongoQuery<DBRundownPlaylist> = {
 		$and: [
 			{
@@ -181,5 +182,5 @@ function rundownPlaylistFilter(
 		}
 	})
 
-	return RundownPlaylists.findOne(selector)
+	return RundownPlaylists.findOneAsync(selector)
 }

meteor/server/api/deviceTriggers/triggersContextCollection.ts

@@ -2,6 +2,24 @@ import type { Collection as RawCollection, Db as RawDb } from 'mongodb'
 import { MongoFieldSpecifier, MongoModifier, MongoQuery, SortSpecifier } from '@sofie-automation/corelib/dist/mongo'
 import { ProtectedString } from '@sofie-automation/corelib/dist/protectedString'
 
+export interface MongoAsyncReadOnlyCollection<DBInterface extends { _id: ProtectedString<any> }> {
+	/**
+	 * Find and return multiple documents
+	 * @param selector A query describing the documents to find
+	 * @param options Options for the operation
+	 */
+	findFetchAsync(selector: MongoQuery<DBInterface>, options?: FindOptions<DBInterface>): Promise<Array<DBInterface>>
+
+	/**
+	 * Finds the first document that matches the selector, as ordered by sort and skip options. Returns `undefined` if no matching document is found.
+	 * @param selector A query describing the documents to find
+	 */
+	findOneAsync(
+		selector: MongoQuery<DBInterface> | DBInterface['_id'],
+		options?: FindOneOptions<DBInterface>
+	): Promise<DBInterface | undefined>
+}
+
 export interface MongoReadOnlyCollection<DBInterface extends { _id: ProtectedString<any> }> {
 	/**
 	 * Find the documents in a collection that match the selector.
@@ -109,32 +127,17 @@ export interface MongoLiveQueryHandle {
 }
 
 // Note: This is a subset of the Meteor Mongo.Cursor type
-export interface MongoCursor<DBInterface extends { _id: ProtectedString<any> }> {
-	/**
-	 * Returns the number of documents that match a query.
-	 * @param applySkipLimit If set to `false`, the value returned will reflect the total number of matching documents, ignoring any value supplied for limit. (Default: true)
-	 */
-	count(applySkipLimit?: boolean): number
+
+export interface MongoAsyncCursor<DBInterface extends { _id: ProtectedString<any> }> {
 	/**
 	 * Returns the number of documents that match a query.
 	 * @param applySkipLimit If set to `false`, the value returned will reflect the total number of matching documents, ignoring any value supplied for limit. (Default: true)
 	 */
 	countAsync(applySkipLimit?: boolean): Promise<number>
-	/**
-	 * Return all matching documents as an Array.
-	 */
-	fetch(): Array<DBInterface>
 	/**
 	 * Return all matching documents as an Array.
 	 */
 	fetchAsync(): Promise<Array<DBInterface>>
-	/**
-	 * Call `callback` once for each matching document, sequentially and
-	 *          synchronously.
-	 * @param callback Function to call. It will be called with three arguments: the document, a 0-based index, and <em>cursor</em> itself.
-	 * @param thisArg An object which will be the value of `this` inside `callback`.
-	 */
-	forEach(callback: (doc: DBInterface, index: number, cursor: MongoCursor<DBInterface>) => void, thisArg?: any): void
 	/**
 	 * Call `callback` once for each matching document, sequentially and
 	 *          synchronously.
@@ -150,19 +153,54 @@ export interface MongoCursor<DBInterface extends { _id: ProtectedString<any> }>
 	 * @param callback Function to call. It will be called with three arguments: the document, a 0-based index, and <em>cursor</em> itself.
 	 * @param thisArg An object which will be the value of `this` inside `callback`.
 	 */
-	map<M>(callback: (doc: DBInterface, index: number, cursor: MongoCursor<DBInterface>) => M, thisArg?: any): Array<M>
+	mapAsync<M>(
+		callback: (doc: DBInterface, index: number, cursor: MongoCursor<DBInterface>) => M,
+		thisArg?: any
+	): Promise<Array<M>>
+
+	[Symbol.asyncIterator](): AsyncIterator<DBInterface, never, never>
+
+	/**
+	 * Watch a query. Receive callbacks as the result set changes.
+	 * @param callbacks Functions to call to deliver the result set as it changes
+	 */
+	observeAsync(callbacks: ObserveCallbacks<DBInterface>): Promise<MongoLiveQueryHandle>
+	/**
+	 * Watch a query. Receive callbacks as the result set changes. Only the differences between the old and new documents are passed to the callbacks.
+	 * @param callbacks Functions to call to deliver the result set as it changes
+	 * @param options { nonMutatingCallbacks: boolean }
+	 */
+	observeChangesAsync(
+		callbacks: ObserveChangesCallbacks<DBInterface>,
+		options?: { nonMutatingCallbacks?: boolean | undefined }
+	): Promise<MongoLiveQueryHandle>
+}
+
+export interface MongoCursor<DBInterface extends { _id: ProtectedString<any> }> extends MongoAsyncCursor<DBInterface> {
+	/**
+	 * Returns the number of documents that match a query.
+	 * @param applySkipLimit If set to `false`, the value returned will reflect the total number of matching documents, ignoring any value supplied for limit. (Default: true)
+	 */
+	count(applySkipLimit?: boolean): number
+	/**
+	 * Return all matching documents as an Array.
+	 */
+	fetch(): Array<DBInterface>
+	/**
+	 * Call `callback` once for each matching document, sequentially and
+	 *          synchronously.
+	 * @param callback Function to call. It will be called with three arguments: the document, a 0-based index, and <em>cursor</em> itself.
+	 * @param thisArg An object which will be the value of `this` inside `callback`.
+	 */
+	forEach(callback: (doc: DBInterface, index: number, cursor: MongoCursor<DBInterface>) => void, thisArg?: any): void
 	/**
 	 * Map callback over all matching documents. Returns an Array.
 	 * @param callback Function to call. It will be called with three arguments: the document, a 0-based index, and <em>cursor</em> itself.
 	 * @param thisArg An object which will be the value of `this` inside `callback`.
 	 */
-	mapAsync<M>(
-		callback: (doc: DBInterface, index: number, cursor: MongoCursor<DBInterface>) => M,
-		thisArg?: any
-	): Promise<Array<M>>
+	map<M>(callback: (doc: DBInterface, index: number, cursor: MongoCursor<DBInterface>) => M, thisArg?: any): Array<M>
 
 	[Symbol.iterator](): Iterator<DBInterface, never, never>
-	[Symbol.asyncIterator](): AsyncIterator<DBInterface, never, never>
 
 	/**
 	 * Watch a query. Receive callbacks as the result set changes.