chore: move external id lookup out of playout code

Author: justandras

packages/blueprints-integration/src/context/onTakeContext.ts

@@ -38,11 +38,13 @@ export interface IOnTakeContext
 /**
  * Insertion point for {@link IPlayoutActionContext.queuePart} and {@link IOnTakeContext.queuePartAfterTake}.
  * Specify exactly one of `targetPartId` or `targetPartInstanceId`.
+ * `targetPartId` may be a Part `_id` or `externalId`; Core converts it to `_id` before playout.
  * Inserts before the target unless `after` is true.
  */
 export type QueuePartTarget = { after?: boolean } & (QueuePartTargetProps | QueuePartInstanceTargetProps)
 
 interface QueuePartTargetProps {
+	/** Part `_id` or `externalId` */
 	targetPartId: string
 	targetPartInstanceId?: never
 }

packages/job-worker/src/blueprints/context/services/PartAndPieceInstanceActionService.ts

@@ -49,7 +49,13 @@ import {
 	PieceTimelineObjectsBlob,
 	serializePieceTimelineObjectsBlob,
 } from '@sofie-automation/corelib/dist/dataModel/Piece'
-import { PartInstanceId, PieceInstanceId, RundownId, SegmentId } from '@sofie-automation/corelib/dist/dataModel/Ids'
+import {
+	PartId,
+	PartInstanceId,
+	PieceInstanceId,
+	RundownId,
+	SegmentId,
+} from '@sofie-automation/corelib/dist/dataModel/Ids'
 import {
 	protectString,
 	unprotectString,
@@ -102,6 +108,24 @@ export class PartAndPieceInstanceActionService {
 		this.showStyleCompound = showStyle
 	}
 
+	/**
+	 * Convert blueprint `targetPartId` to an internal Part `_id`.
+	 * Accepts either `_id` or `externalId`; playout only ever sees `_id`.
+	 */
+	#toInternalQueuePartTarget(target?: QueuePartTarget): QueuePartTarget | undefined {
+		if (!target?.targetPartId) return target
+
+		const part =
+			this._playoutModel.findPart(protectString<PartId>(target.targetPartId)) ??
+			this._playoutModel.getAllOrderedParts().find((p) => p.externalId === target.targetPartId)
+		if (!part) return target
+
+		return {
+			...target,
+			targetPartId: unprotectString(part._id),
+		}
+	}
+
 	#assertInsertTargetShowStyleCompatible(insertTarget: QueuedAdlibInsertTarget): void {
 		if (insertTarget.targetRundown.rundown.showStyleVariantId !== this.showStyleCompound.showStyleVariantId) {
 			throw new Error(
@@ -426,7 +450,8 @@ export class PartAndPieceInstanceActionService {
 			throw new Error('Too close to an autonext to queue a part')
 		}
 
-		const insertTarget = resolveQueuedAdlibInsertTarget(this._playoutModel, currentPartInstance, target)
+		const internalTarget = this.#toInternalQueuePartTarget(target)
+		const insertTarget = resolveQueuedAdlibInsertTarget(this._playoutModel, currentPartInstance, internalTarget)
 		this.#assertInsertTargetShowStyleCompatible(insertTarget)
 
 		const processedPartsAndPieces = this.processPartAndPiecesToQueueOrFail(
@@ -441,7 +466,7 @@ export class PartAndPieceInstanceActionService {
 			this._context,
 			this._playoutModel,
 			currentPartInstance,
-			{ ...processedPartsAndPieces, target },
+			{ ...processedPartsAndPieces, target: internalTarget },
 			undefined,
 			insertTarget
 		)
@@ -458,7 +483,8 @@ export class PartAndPieceInstanceActionService {
 		currentPartInstance: PlayoutPartInstanceModel,
 		target?: QueuePartTarget
 	): QueueablePartAndPieces {
-		const insertTarget = resolveQueuedAdlibInsertTarget(this._playoutModel, currentPartInstance, target)
+		const internalTarget = this.#toInternalQueuePartTarget(target)
+		const insertTarget = resolveQueuedAdlibInsertTarget(this._playoutModel, currentPartInstance, internalTarget)
 		this.#assertInsertTargetShowStyleCompatible(insertTarget)
 
 		const { part, pieces } = this.processPartAndPiecesToQueueOrFail(
@@ -468,7 +494,7 @@ export class PartAndPieceInstanceActionService {
 			insertTarget.targetSegment.segment._id
 		)
 
-		return { part, pieces, target }
+		return { part, pieces, target: internalTarget }
 	}
 
 	public processPartAndPiecesToQueueOrFail(

packages/job-worker/src/blueprints/context/services/__tests__/PartAndPieceInstanceActionService.test.ts

@@ -1285,6 +1285,53 @@ describe('Test blueprint api context', () => {
 				})
 			})
 
+			test('good with explicit insert before part externalId', async () => {
+				const { jobContext, playlistId, rundownId } = await setupMyDefaultRundown()
+
+				const partInstance = (await jobContext.mockCollections.PartInstances.findOne({
+					rundownId,
+					'part.externalId': 'MOCK_PART_0_0',
+				})) as DBPartInstance
+				expect(partInstance).toBeTruthy()
+				await setPartInstances(jobContext, playlistId, partInstance, undefined)
+
+				const targetPart = await jobContext.mockCollections.Parts.findOne({
+					externalId: 'MOCK_PART_1_1',
+					rundownId,
+				})
+				expect(targetPart).toBeTruthy()
+
+				await wrapWithPlayoutModel(jobContext, playlistId, async (playoutModel) => {
+					const { service } = await getTestee(jobContext, playoutModel)
+
+					const newPiece: IBlueprintPiece = {
+						name: 'test piece',
+						sourceLayerId: 'sl1',
+						outputLayerId: 'o1',
+						externalId: '-',
+						enable: { start: 0 },
+						lifespan: PieceLifespan.OutOnRundownEnd,
+						content: {
+							timelineObjects: [],
+						},
+					}
+					const newPart: IBlueprintPart = {
+						externalId: 'nope',
+						title: 'something',
+					}
+
+					postProcessPiecesMock.mockImplementationOnce(postProcessPiecesOrig)
+					insertQueuedPartWithPiecesMock.mockImplementationOnce(insertQueuedPartWithPiecesOrig)
+					await service.queuePart(newPart, [newPiece], { targetPartId: 'MOCK_PART_1_1' })
+
+					const newPartInstance = playoutModel.getPartInstance(
+						playoutModel.playlist.nextPartInfo!.partInstanceId
+					)!
+					expect(newPartInstance.partInstance.segmentId).toEqual(targetPart!.segmentId)
+					expect(newPartInstance.partInstance.part._rank).toBeLessThan(targetPart!._rank)
+				})
+			})
+
 			test('unknown insert before part id', async () => {
 				const { jobContext, playlistId, rundownId } = await setupMyDefaultRundown()
 
@@ -1578,6 +1625,52 @@ describe('Test blueprint api context', () => {
 				})
 			})
 
+			test('prepareQueueablePartAndPieces converts targetPartId from externalId to _id', async () => {
+				const { jobContext, playlistId, rundownId } = await setupMyDefaultRundown()
+
+				const partInstance = (await jobContext.mockCollections.PartInstances.findOne({
+					rundownId,
+					'part.externalId': 'MOCK_PART_0_0',
+				})) as DBPartInstance
+				expect(partInstance).toBeTruthy()
+				await setPartInstances(jobContext, playlistId, partInstance, undefined)
+
+				const targetPart = await jobContext.mockCollections.Parts.findOne({
+					externalId: 'MOCK_PART_1_1',
+					rundownId,
+				})
+				expect(targetPart).toBeTruthy()
+
+				await wrapWithPlayoutModel(jobContext, playlistId, async (playoutModel) => {
+					const { service } = await getTestee(jobContext, playoutModel)
+
+					const currentPartInstance = playoutModel.currentPartInstance!
+					postProcessPiecesMock.mockImplementationOnce(postProcessPiecesOrig)
+
+					const queueable = service.prepareQueueablePartAndPieces(
+						{ externalId: 'nope', title: 'something' },
+						[
+							{
+								name: 'test piece',
+								sourceLayerId: 'sl1',
+								outputLayerId: 'o1',
+								externalId: '-',
+								enable: { start: 0 },
+								lifespan: PieceLifespan.OutOnRundownEnd,
+								content: {
+									timelineObjects: [],
+								},
+							},
+						],
+						currentPartInstance,
+						{ targetPartId: 'MOCK_PART_1_1' }
+					)
+
+					expect(queueable.target?.targetPartId).toEqual(unprotectString(targetPart!._id))
+					expect(queueable.target?.targetPartId).not.toEqual('MOCK_PART_1_1')
+				})
+			})
+
 			test('good with explicit insert after part id', async () => {
 				const { jobContext, playlistId, rundownId } = await setupMyDefaultRundown()
 

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

@@ -3,7 +3,6 @@ import { ReadonlyDeep } from 'type-fest'
 import { DBSegment, SegmentOrphanedReason } from '@sofie-automation/corelib/dist/dataModel/Segment'
 import { DBPart } from '@sofie-automation/corelib/dist/dataModel/Part'
 import { PlayoutSegmentModel } from '../PlayoutSegmentModel.js'
-import { unprotectString } from '@sofie-automation/corelib/dist/protectedString'
 
 export class PlayoutSegmentModelImpl implements PlayoutSegmentModel {
 	readonly #segment: DBSegment
@@ -21,7 +20,7 @@ export class PlayoutSegmentModelImpl implements PlayoutSegmentModel {
 	}
 
 	getPart(id: PartId): ReadonlyDeep<DBPart> | undefined {
-		return this.parts.find((part) => part._id === id || part.externalId === unprotectString(id))
+		return this.parts.find((part) => part._id === id)
 	}
 
 	getPartIds(): PartId[] {

packages/job-worker/src/playout/model/implementation/__tests__/PlayoutSegmentModelImpl.spec.ts

@@ -69,6 +69,22 @@ describe('PlayoutSegmentModelImpl', () => {
 
 			expect(model.getPart(fakePart._id)).toBe(fakePart)
 		})
+		it('matches by _id even when another part has that id as externalId and a lower rank', async () => {
+			const byId: DBPart = { _id: protectString('part0'), _rank: 5, externalId: 'other' } as any
+			const byExternalId: DBPart = { _id: protectString('part1'), _rank: 1, externalId: 'part0' } as any
+			const segment = createBasicDBSegment()
+			const model = new PlayoutSegmentModelImpl(segment, [byId, byExternalId])
+
+			expect(model.getPart(byId._id)).toBe(byId)
+			expect(model.getPart(protectString('part0'))).toBe(byId)
+		})
+		it('does not match by externalId', async () => {
+			const fakePart: DBPart = { _id: protectString('part0'), _rank: 1, externalId: 'ext-part' } as any
+			const segment = createBasicDBSegment()
+			const model = new PlayoutSegmentModelImpl(segment, [fakePart])
+
+			expect(model.getPart(protectString('ext-part'))).toBeUndefined()
+		})
 	})
 
 	describe('setAdlibTestingRank', () => {