From 5777ef3532201cb779e52fda79f51c137faabca6 Mon Sep 17 00:00:00 2001
From: Carlos Valente <carlosvalente@pm.me>
Date: Fri, 13 Feb 2026 19:59:57 +0100
Subject: [PATCH] refactor: extract parent resolution

---
 .../src/api-data/rundown/rundown.service.ts   | 25 +++---------
 packages/utils/index.ts                       |  1 +
 .../src/rundown-utils/rundownUtils.test.ts    | 38 +++++++++++++++++++
 .../utils/src/rundown-utils/rundownUtils.ts   | 26 +++++++++++++
 4 files changed, 71 insertions(+), 19 deletions(-)

diff --git a/apps/server/src/api-data/rundown/rundown.service.ts b/apps/server/src/api-data/rundown/rundown.service.ts
index 5ad4fb562..f4d37c24a 100644
--- a/apps/server/src/api-data/rundown/rundown.service.ts
+++ b/apps/server/src/api-data/rundown/rundown.service.ts
@@ -16,7 +16,7 @@ import {
   ProjectRundowns,
   InsertOptions,
 } from 'ontime-types';
-import { customFieldLabelToKey, getInsertAfterId } from 'ontime-utils';
+import { customFieldLabelToKey, getInsertAfterId, resolveInsertParent } from 'ontime-utils';
 
 import { updateRundownData } from '../../stores/runtimeState.js';
 import { runtimeService } from '../../services/runtime-service/runtime.service.js';
@@ -47,28 +47,15 @@ export async function addEntry(eventData: EventPostPayload): Promise<OntimeEntry
     throw new Error(`Event with ID ${eventData.id} already exists`);
   }
 
-  // the parent can be provided or inferred from position
+  // resolve the parent, either from the payload or inferred from sibling position
+  const parentId = resolveInsertParent(rundown, eventData);
   let parent: OntimeGroup | null = null;
-
-  if ('parent' in eventData && eventData.parent != null) {
-    // if the user provides a parent (inside a group), we make sure it exists and it is a group
-    const maybeParent = rundown.entries[eventData.parent];
+  if (parentId) {
+    const maybeParent = rundown.entries[parentId];
     if (!maybeParent || !isOntimeGroup(maybeParent)) {
-      throw new Error(`Invalid parent event with ID ${eventData.parent}`);
+      throw new Error(`Invalid parent event with ID ${parentId}`);
     }
     parent = maybeParent;
-  } else {
-    // otherwise, we may infer the parent from relative positioning (after/before)
-    const referenceId = eventData?.after ?? eventData?.before;
-    if (referenceId) {
-      const maybeSibling = rundown.entries[referenceId];
-      if (maybeSibling && 'parent' in maybeSibling && maybeSibling.parent) {
-        const maybeParent = rundown.entries[maybeSibling.parent];
-        if (maybeParent && isOntimeGroup(maybeParent)) {
-          parent = maybeParent;
-        }
-      }
-    }
   }
 
   // normalise the position of the event in the rundown order
diff --git a/packages/utils/index.ts b/packages/utils/index.ts
index 227a0fb53..8de7d4fe7 100644
--- a/packages/utils/index.ts
+++ b/packages/utils/index.ts
@@ -26,6 +26,7 @@ export {
   getPreviousEventNormal,
   getPreviousNormal,
   getPreviousGroupNormal,
+  resolveInsertParent,
   swapEventData,
 } from './src/rundown-utils/rundownUtils.js';
 export { getFirstRundown } from './src/rundown/rundown.utils.js';
diff --git a/packages/utils/src/rundown-utils/rundownUtils.test.ts b/packages/utils/src/rundown-utils/rundownUtils.test.ts
index ad65f4958..bc301815b 100644
--- a/packages/utils/src/rundown-utils/rundownUtils.test.ts
+++ b/packages/utils/src/rundown-utils/rundownUtils.test.ts
@@ -13,6 +13,7 @@ import {
   getNextNormal,
   getPreviousGroupNormal,
   getPreviousNormal,
+  resolveInsertParent,
   swapEventData,
 } from './rundownUtils';
 import { demoDb } from './rundownUtils.mock';
@@ -272,6 +273,43 @@ describe('getInsertAfterId()', () => {
   });
 });
 
+describe('resolveInsertParent()', () => {
+  const rundown = {
+    id: 'test',
+    title: 'test',
+    entries: {
+      top: { id: 'top', type: SupportedEntry.Event, parent: null } as OntimeEvent,
+      group: { id: 'group', type: SupportedEntry.Group, entries: ['31', '32'] } as unknown as OntimeGroup,
+      '31': { id: '31', type: SupportedEntry.Event, parent: 'group' } as OntimeEvent,
+      '32': { id: '32', type: SupportedEntry.Event, parent: 'group' } as OntimeEvent,
+    },
+    order: ['top', 'group'],
+    flatOrder: ['top', 'group', '31', '32'],
+    revision: 1,
+  } as Rundown;
+
+  it('returns explicit parent id', () => {
+    expect(resolveInsertParent(rundown, { parent: 'group' })).toBe('group');
+  });
+
+  it('returns non-existent explicit parent id as-is', () => {
+    expect(resolveInsertParent(rundown, { parent: 'missing' })).toBe('missing');
+  });
+
+  it('infers parent id from sibling when parent is omitted', () => {
+    expect(resolveInsertParent(rundown, { after: '31' })).toBe('group');
+    expect(resolveInsertParent(rundown, { before: '32' })).toBe('group');
+  });
+
+  it('returns null when no grouped sibling reference exists', () => {
+    expect(resolveInsertParent(rundown, { after: 'top' })).toBeNull();
+  });
+
+  it('returns null when no references are provided', () => {
+    expect(resolveInsertParent(rundown, {})).toBeNull();
+  });
+});
+
 describe('addToRundown()', () => {
   const makeTestRundown = (): Rundown =>
     ({
diff --git a/packages/utils/src/rundown-utils/rundownUtils.ts b/packages/utils/src/rundown-utils/rundownUtils.ts
index 9ee86de8e..90d6aa658 100644
--- a/packages/utils/src/rundown-utils/rundownUtils.ts
+++ b/packages/utils/src/rundown-utils/rundownUtils.ts
@@ -382,6 +382,32 @@ export function getInsertAfterId(
   return insertionList[atIndex - 1];
 }
 
+type ResolveInsertParentOptions = {
+  parent?: EntryId | null;
+  after?: EntryId;
+  before?: EntryId;
+};
+
+/**
+ * Resolves the parent ID for an insertion.
+ * Uses explicit parent first, then infers from sibling references.
+ */
+export function resolveInsertParent(rundown: Rundown, options: ResolveInsertParentOptions): EntryId | null {
+  if (options.parent) {
+    return options.parent;
+  }
+
+  const referenceId = options.after ?? options.before;
+  if (!referenceId) return null;
+
+  const maybeSibling = rundown.entries[referenceId];
+  if (maybeSibling && 'parent' in maybeSibling && maybeSibling.parent) {
+    return maybeSibling.parent;
+  }
+
+  return null;
+}
+
 /**
  * Add entry to rundown, mutates the rundown in place.
  * Handles the following cases: