feat: change structure of ExpectedPackage documents

This is a preparation step for the documents having multiple owners. In the current iteration, each document will remain with one owner.

Author: Julusian

meteor/server/api/__tests__/cleanup.test.ts

@@ -193,7 +193,7 @@ async function setDefaultDatatoDB(env: DefaultEnvironment, now: number) {
 		startSegmentId: segmentId,
 		timelineObjectsString: '' as any,
 	}
-	const pieceId = await Pieces.mutableCollection.insertAsync(piece)
+	await Pieces.mutableCollection.insertAsync(piece)
 
 	await AdLibActions.mutableCollection.insertAsync({
 		_id: getRandomId(),
@@ -256,21 +256,12 @@ async function setDefaultDatatoDB(env: DefaultEnvironment, now: number) {
 	})
 	const packageId = await ExpectedPackages.mutableCollection.insertAsync({
 		_id: getRandomId(),
-		blueprintPackageId: '',
-		bucketId,
-		content: {} as any,
-		contentVersionHash: '',
-		created: 0,
-		fromPieceType: '' as any,
-		layers: [],
-		pieceId,
-		rundownId,
-		segmentId,
-		sideEffect: {} as any,
 		studioId,
-		sources: {} as any,
-		type: '' as any,
-		version: {} as any,
+		rundownId,
+		bucketId: null,
+		created: 0,
+		package: {} as any,
+		ingestSources: [] as any,
 	})
 	await ExpectedPackageWorkStatuses.insertAsync({
 		_id: getRandomId(),

meteor/server/api/ingest/debug.ts

@@ -8,7 +8,6 @@ import { QueueStudioJob } from '../../worker/worker'
 import { StudioJobs } from '@sofie-automation/corelib/dist/worker/studio'
 import { RundownPlaylistId, SegmentId } from '@sofie-automation/corelib/dist/dataModel/Ids'
 import { MeteorDebugMethods } from '../../methods'
-import { DBRundown } from '@sofie-automation/corelib/dist/dataModel/Rundown'
 
 MeteorDebugMethods({
 	/**
@@ -47,31 +46,4 @@ MeteorDebugMethods({
 			segmentExternalId: segment.externalId,
 		})
 	},
-	/**
-	 * Regenerate all the expected packages for all rundowns in the system.
-	 * Additionally it will recreate any expectedMediaItems and expectedPlayoutItems.
-	 * This shouldn't be necessary as ingest will do this for each rundown as part of its workflow
-	 */
-	debug_recreateExpectedPackages: async () => {
-		const rundowns = (await Rundowns.findFetchAsync(
-			{},
-			{
-				projection: {
-					_id: 1,
-					studioId: 1,
-					source: 1,
-				},
-			}
-		)) as Array<Pick<DBRundown, '_id' | 'studioId' | 'source'>>
-
-		await Promise.all(
-			rundowns
-				.filter((rundown) => rundown.source.type !== 'snapshot')
-				.map(async (rundown) =>
-					runIngestOperation(rundown.studioId, IngestJobs.ExpectedPackagesRegenerate, {
-						rundownId: rundown._id,
-					})
-				)
-		)
-	},
 })

meteor/server/api/ingest/packageInfo.ts

@@ -1,10 +1,7 @@
 import {
-	ExpectedPackageDBFromBucketAdLib,
-	ExpectedPackageDBFromBucketAdLibAction,
-	ExpectedPackageDBFromStudioBaselineObjects,
 	ExpectedPackageDBType,
-	ExpectedPackageFromRundown,
-	ExpectedPackageFromRundownBaseline,
+	ExpectedPackageDB,
+	ExpectedPackageIngestSourceBucket,
 } from '@sofie-automation/corelib/dist/dataModel/ExpectedPackages'
 import { PackageInfoDB } from '@sofie-automation/corelib/dist/dataModel/PackageInfos'
 import { ExpectedPackages, Rundowns } from '../../collections'
@@ -28,51 +25,58 @@ export async function onUpdatedPackageInfo(packageId: ExpectedPackageId, _doc: P
 		return
 	}
 
-	if (pkg.listenToPackageInfoUpdates) {
-		switch (pkg.fromPieceType) {
-			case ExpectedPackageDBType.PIECE:
-			case ExpectedPackageDBType.ADLIB_PIECE:
-			case ExpectedPackageDBType.ADLIB_ACTION:
-			case ExpectedPackageDBType.BASELINE_ADLIB_PIECE:
-			case ExpectedPackageDBType.BASELINE_ADLIB_ACTION:
-			case ExpectedPackageDBType.RUNDOWN_BASELINE_OBJECTS:
-				onUpdatedPackageInfoForRundownDebounce(pkg)
-				break
-			case ExpectedPackageDBType.BUCKET_ADLIB:
-			case ExpectedPackageDBType.BUCKET_ADLIB_ACTION:
-				onUpdatedPackageInfoForBucketItemDebounce(pkg)
-				break
-			case ExpectedPackageDBType.STUDIO_BASELINE_OBJECTS:
-				onUpdatedPackageInfoForStudioBaselineDebounce(pkg)
-				break
-			default:
-				assertNever(pkg)
-				break
+	if (pkg.package.listenToPackageInfoUpdates) {
+		for (const source of pkg.ingestSources) {
+			switch (source.fromPieceType) {
+				case ExpectedPackageDBType.PIECE:
+				case ExpectedPackageDBType.ADLIB_PIECE:
+				case ExpectedPackageDBType.ADLIB_ACTION:
+				case ExpectedPackageDBType.BASELINE_ADLIB_PIECE:
+				case ExpectedPackageDBType.BASELINE_ADLIB_ACTION:
+				case ExpectedPackageDBType.RUNDOWN_BASELINE_OBJECTS:
+					onUpdatedPackageInfoForRundownDebounce(pkg)
+					break
+				case ExpectedPackageDBType.BUCKET_ADLIB:
+				case ExpectedPackageDBType.BUCKET_ADLIB_ACTION:
+					onUpdatedPackageInfoForBucketItemDebounce(pkg, source)
+					break
+				case ExpectedPackageDBType.STUDIO_BASELINE_OBJECTS:
+					onUpdatedPackageInfoForStudioBaselineDebounce(pkg)
+					break
+				default:
+					assertNever(source)
+					break
+			}
 		}
 	}
 }
 
 const pendingRundownPackageUpdates = new Map<RundownId, Array<ExpectedPackageId>>()
-function onUpdatedPackageInfoForRundownDebounce(pkg: ExpectedPackageFromRundown | ExpectedPackageFromRundownBaseline) {
-	const existingEntry = pendingRundownPackageUpdates.get(pkg.rundownId)
+function onUpdatedPackageInfoForRundownDebounce(pkg: ExpectedPackageDB) {
+	if (!pkg.rundownId) {
+		logger.error(`Updating ExpectedPackage "${pkg._id}" for Rundown "${pkg.rundownId}" not possible`)
+		return
+	}
+
+	const rundownId = pkg.rundownId
+
+	const existingEntry = pendingRundownPackageUpdates.get(rundownId)
 	if (existingEntry) {
 		// already queued, add to the batch
 		existingEntry.push(pkg._id)
 	} else {
-		pendingRundownPackageUpdates.set(pkg.rundownId, [pkg._id])
+		pendingRundownPackageUpdates.set(rundownId, [pkg._id])
 	}
 
 	// TODO: Scaling - this won't batch correctly if package manager directs calls to multiple instances
 	lazyIgnore(
-		`onUpdatedPackageInfoForRundown_${pkg.rundownId}`,
+		`onUpdatedPackageInfoForRundown_${rundownId}`,
 		() => {
-			const packageIds = pendingRundownPackageUpdates.get(pkg.rundownId)
+			const packageIds = pendingRundownPackageUpdates.get(rundownId)
 			if (packageIds) {
-				pendingRundownPackageUpdates.delete(pkg.rundownId)
-				onUpdatedPackageInfoForRundown(pkg.rundownId, packageIds).catch((e) => {
-					logger.error(
-						`Updating ExpectedPackages for Rundown "${pkg.rundownId}" failed: ${stringifyError(e)}`
-					)
+				pendingRundownPackageUpdates.delete(rundownId)
+				onUpdatedPackageInfoForRundown(rundownId, packageIds).catch((e) => {
+					logger.error(`Updating ExpectedPackages for Rundown "${rundownId}" failed: ${stringifyError(e)}`)
 				})
 			}
 		},
@@ -107,19 +111,24 @@ async function onUpdatedPackageInfoForRundown(
 	})
 }
 
-function onUpdatedPackageInfoForBucketItemDebounce(
-	pkg: ExpectedPackageDBFromBucketAdLib | ExpectedPackageDBFromBucketAdLibAction
-) {
+function onUpdatedPackageInfoForBucketItemDebounce(pkg: ExpectedPackageDB, source: ExpectedPackageIngestSourceBucket) {
+	if (!pkg.bucketId) {
+		logger.error(`Updating ExpectedPackage "${pkg._id}" for Bucket "${pkg.bucketId}" not possible`)
+		return
+	}
+
+	const bucketId = pkg.bucketId
+
 	lazyIgnore(
-		`onUpdatedPackageInfoForBucket_${pkg.studioId}_${pkg.bucketId}_${pkg.pieceExternalId}`,
+		`onUpdatedPackageInfoForBucket_${pkg.studioId}_${bucketId}_${source.pieceExternalId}`,
 		() => {
 			runIngestOperation(pkg.studioId, IngestJobs.BucketItemRegenerate, {
-				bucketId: pkg.bucketId,
-				externalId: pkg.pieceExternalId,
+				bucketId: bucketId,
+				externalId: source.pieceExternalId,
 			}).catch((err) => {
 				logger.error(
-					`Updating ExpectedPackages for Bucket "${pkg.bucketId}" Item "${
-						pkg.pieceExternalId
+					`Updating ExpectedPackages for Bucket "${bucketId}" Item "${
+						source.pieceExternalId
 					}" failed: ${stringifyError(err)}`
 				)
 			})
@@ -128,7 +137,7 @@ function onUpdatedPackageInfoForBucketItemDebounce(
 	)
 }
 
-function onUpdatedPackageInfoForStudioBaselineDebounce(pkg: ExpectedPackageDBFromStudioBaselineObjects) {
+function onUpdatedPackageInfoForStudioBaselineDebounce(pkg: ExpectedPackageDB) {
 	lazyIgnore(
 		`onUpdatedPackageInfoForStudioBaseline_${pkg.studioId}`,
 		() => {

meteor/server/api/integration/expectedPackages.ts

@@ -33,6 +33,7 @@ import {
 } from '../../collections'
 import { logger } from '../../logging'
 import _ from 'underscore'
+import { ExpectedPackageDB } from '@sofie-automation/corelib/dist/dataModel/ExpectedPackages'
 
 export namespace PackageManagerIntegration {
 	export async function updateExpectedPackageWorkStatuses(
@@ -98,9 +99,17 @@ export namespace PackageManagerIntegration {
 					const fromPackageIds = workStatus.fromPackages.map((p) => p.id)
 					if (fromPackageIds.length) {
 						ps.push(
-							ExpectedPackages.findOneAsync({
-								_id: { $in: fromPackageIds },
-							}).then((expPackage) => {
+							ExpectedPackages.findOneAsync(
+								{
+									_id: { $in: fromPackageIds },
+								},
+								{
+									projection: {
+										_id: 1,
+										studioId: 1,
+									},
+								}
+							).then((expPackage: Pick<ExpectedPackageDB, '_id' | 'studioId'> | undefined) => {
 								if (!expPackage)
 									throw new Meteor.Error(404, `ExpectedPackages "${fromPackageIds}" not found`)
 

meteor/server/collections/packages-media.ts

@@ -32,15 +32,17 @@ export const ExpectedPackages = createAsyncOnlyReadOnlyMongoCollection<ExpectedP
 )
 registerIndex(ExpectedPackages, {
 	studioId: 1,
-	fromPieceType: 1,
 })
 registerIndex(ExpectedPackages, {
 	studioId: 1,
-	pieceId: 1,
+	rundownId: 1,
+})
+registerIndex(ExpectedPackages, {
+	studioId: 1,
+	bucketId: 1,
 })
 registerIndex(ExpectedPackages, {
 	rundownId: 1,
-	pieceId: 1,
 })
 
 export const ExpectedPackageWorkStatuses = createAsyncOnlyMongoCollection<ExpectedPackageWorkStatus>(

meteor/server/migration/1_50_0.ts

@@ -33,11 +33,11 @@ import { JSONBlobStringify, JSONSchema, TSR } from '@sofie-automation/blueprints
 import { DEFAULT_MINIMUM_TAKE_SPAN } from '@sofie-automation/shared-lib/dist/core/constants'
 import { PartId } from '@sofie-automation/shared-lib/dist/core/model/Ids'
 import { protectString } from '@sofie-automation/shared-lib/dist/lib/protectedString'
-import { ExpectedPackageDBType } from '@sofie-automation/corelib/dist/dataModel/ExpectedPackages'
 import { AdLibActionId, PieceId, RundownBaselineAdLibActionId } from '@sofie-automation/corelib/dist/dataModel/Ids'
 import { Piece } from '@sofie-automation/corelib/dist/dataModel/Piece'
 import { AdLibPiece } from '@sofie-automation/corelib/dist/dataModel/AdLibPiece'
 import { AdLibAction } from '@sofie-automation/corelib/dist/dataModel/AdlibAction'
+import * as PackagesPreR53 from '@sofie-automation/corelib/dist/dataModel/Old/ExpectedPackagesR52'
 
 // Release 50
 
@@ -155,9 +155,9 @@ const oldDeviceTypeToNewMapping = {
 }
 
 const EXPECTED_PACKAGE_TYPES_ADDED_PART_ID = [
-	ExpectedPackageDBType.PIECE,
-	ExpectedPackageDBType.ADLIB_PIECE,
-	ExpectedPackageDBType.ADLIB_ACTION,
+	PackagesPreR53.ExpectedPackageDBType.PIECE,
+	PackagesPreR53.ExpectedPackageDBType.ADLIB_PIECE,
+	PackagesPreR53.ExpectedPackageDBType.ADLIB_ACTION,
 ]
 
 export const addSteps = addMigrationSteps('1.50.0', [
@@ -871,10 +871,10 @@ export const addSteps = addMigrationSteps('1.50.0', [
 			return false
 		},
 		migrate: async () => {
-			const objects = await ExpectedPackages.findFetchAsync({
+			const objects = (await ExpectedPackages.findFetchAsync({
 				fromPieceType: { $in: EXPECTED_PACKAGE_TYPES_ADDED_PART_ID as any }, // Force the types, as the query does not match due to the interfaces
 				partId: { $exists: false },
-			})
+			})) as unknown as Array<PackagesPreR53.ExpectedPackageDB>
 
 			const neededPieceIds: Array<PieceId | AdLibActionId | RundownBaselineAdLibActionId> = _.compact(
 				objects.map((obj) => obj.pieceId)