@byline/admin 4.4.0 → 4.5.0

package/src/forms/pending-uploads.test.node.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { deletePendingUploadsUnderPath } from './pending-uploads'
+
+describe('deletePendingUploadsUnderPath', () => {
+  it('removes and revokes only uploads beneath the removed item', () => {
+    const uploads = new Map([
+      ['content[id=a].image', { previewUrl: 'blob:a' }],
+      ['content[id=b].image', { previewUrl: 'blob:b' }],
+      ['content[id=b].gallery[id=x].image', { previewUrl: 'blob:nested' }],
+    ])
+    const revoke = vi.fn()
+
+    expect(deletePendingUploadsUnderPath(uploads, 'content[id=b]', revoke)).toBe(true)
+    expect([...uploads.keys()]).toEqual(['content[id=a].image'])
+    expect(revoke.mock.calls).toEqual([['blob:b'], ['blob:nested']])
+  })
+
+  it('reports when no pending upload matched', () => {
+    const uploads = new Map([['content[id=a].image', { previewUrl: 'blob:a' }]])
+    expect(deletePendingUploadsUnderPath(uploads, 'content[id=b]', vi.fn())).toBe(false)
+  })
+})

package/src/forms/pending-uploads.ts

@@ -0,0 +1,22 @@
+interface PendingUploadLike {
+  previewUrl: string
+}
+
+/** Remove deferred uploads belonging to one repeating item and its descendants. */
+export function deletePendingUploadsUnderPath<T extends PendingUploadLike>(
+  uploads: Map<string, T>,
+  itemPath: string,
+  revokeObjectURL: (url: string) => void
+): boolean {
+  const descendantPrefix = `${itemPath}.`
+  let deleted = false
+
+  for (const [fieldPath, upload] of uploads) {
+    if (fieldPath !== itemPath && !fieldPath.startsWith(descendantPrefix)) continue
+    revokeObjectURL(upload.previewUrl)
+    uploads.delete(fieldPath)
+    deleted = true
+  }
+
+  return deleted
+}

package/src/forms/repeating-items.test.node.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest'
+
+import { moveRepeatingItems, repeatingItemId, repeatingItemPath } from './repeating-items'
+
+describe('repeatingItemPath', () => {
+  it('uses stable storage identity when available', () => {
+    expect(repeatingItemPath('content', { _id: 'block-b' }, 1)).toBe('content[id=block-b]')
+  })
+
+  it('falls back to position for id-less or path-unsafe identities', () => {
+    expect(repeatingItemPath('content', {}, 1)).toBe('content[1]')
+    expect(repeatingItemPath('content', { _id: 'unsafe.id' }, 1)).toBe('content[1]')
+    expect(repeatingItemPath('content', { _id: null }, 1)).toBe('content[1]')
+    expect(repeatingItemId({ _id: 42 })).toBeUndefined()
+  })
+})
+
+describe('moveRepeatingItems', () => {
+  const ids = (items: { _id: string }[]) => items.map((item) => item._id)
+
+  it('keeps consecutive moves aligned with the current form-store order', () => {
+    const first = moveRepeatingItems([{ _id: 'a' }, { _id: 'b' }, { _id: 'c' }], 2, 0)
+    expect(first?.itemId).toBe('c')
+    expect(ids(first?.items ?? [])).toEqual(['c', 'a', 'b'])
+
+    const second = moveRepeatingItems(first?.items ?? [], 2, 1)
+    expect(second?.itemId).toBe('b')
+    expect(ids(second?.items ?? [])).toEqual(['c', 'b', 'a'])
+  })
+
+  it('retains the positional patch fallback for id-less items', () => {
+    const moved = moveRepeatingItems([{ value: 'a' }, { value: 'b' }], 1, 0)
+    expect(moved?.itemId).toBe('1')
+    expect(moved?.items.map((item) => item.value)).toEqual(['b', 'a'])
+  })
+})

package/src/forms/repeating-items.ts

@@ -0,0 +1,48 @@
+/** Return a canonical identity that is safe in an instance-path selector. */
+export function repeatingItemId(item: unknown): string | undefined {
+  if (item == null || typeof item !== 'object' || !('_id' in item)) return undefined
+  const id = (item as { _id: unknown })._id
+  return typeof id === 'string' && id !== '' && !/[.[\]]/.test(id) ? id : undefined
+}
+
+/**
+ * Address an array/block item by stable identity when its id is path-safe.
+ * Positional fallback is retained for noncanonical create defaults and legacy
+ * adapter data that does not carry storage identity yet.
+ */
+export function repeatingItemPath(parentPath: string, item: unknown, index: number): string {
+  const id = repeatingItemId(item)
+  return id != null ? `${parentPath}[id=${id}]` : `${parentPath}[${index}]`
+}
+
+export interface RepeatingItemMove<T> {
+  items: T[]
+  itemId: string
+  fromIndex: number
+  toIndex: number
+}
+
+/** Build one synchronized form-store move and its matching patch identity. */
+export function moveRepeatingItems<T>(
+  items: readonly T[],
+  moveFromIndex: number,
+  moveToIndex: number
+): RepeatingItemMove<T> | null {
+  if (items.length === 0) return null
+
+  const fromIndex = Math.max(0, Math.min(moveFromIndex, items.length - 1))
+  const toIndex = Math.max(0, Math.min(moveToIndex, items.length - 1))
+  if (fromIndex === toIndex) return null
+
+  const source = items[fromIndex]
+  const moved = [...items]
+  const [item] = moved.splice(fromIndex, 1)
+  moved.splice(toIndex, 0, item as T)
+
+  return {
+    items: moved,
+    itemId: repeatingItemId(source) ?? String(fromIndex),
+    fromIndex,
+    toIndex,
+  }
+}

package/src/forms/upload-executor.test.node.ts

@@ -99,10 +99,20 @@ const blocksFields: Field[] = [
                 name: 'poster',
                 label: 'Poster',
                 type: 'image',
-                upload: { context: ['/title'] },
+                upload: { context: ['../caption', '/title'] },
               },
             ],
           },
+          { name: 'caption', label: 'Caption', type: 'text' },
+          {
+            // Declared directly on the block, unlike `poster` above. This is
+            // the only depth at which `..` must leave the block entirely, so
+            // it is the only depth that can detect a scope miscount.
+            name: 'blockFile',
+            label: 'Block file',
+            type: 'file',
+            upload: { context: ['caption', '../title'] },
+          },
         ],
       },
     ],
@@ -113,8 +123,13 @@ const blocksFields: Field[] = [
 const blocksFormValues = () => ({
   title: 'Hello',
   content: [
-    { _type: 'photoBlock', _id: 'blk-photo', gallery: [{}] },
-    { _type: 'videoBlock', _id: 'blk-video', gallery: [{}] },
+    { _type: 'photoBlock', _id: 'blk-photo', gallery: [{ _id: 'gallery-photo' }] },
+    {
+      _type: 'videoBlock',
+      _id: 'blk-video',
+      gallery: [{ _id: 'gallery-video' }],
+      caption: 'Video caption',
+    },
   ],
 })
 
@@ -295,6 +310,52 @@ describe('executeUploads — upload fields inside blocks', () => {
     expect(bodies[0]?.get('title')).toBe('Hello')
   })
 
+  it('resolves sibling context through stable outer and inner item paths', async () => {
+    const { fn, bodies } = captureUploadField()
+    const uploads = new Map([
+      ['content[id=blk-video].gallery[id=gallery-video].poster', imageUpload()],
+    ])
+
+    await executeUploads(uploads, fn, {
+      fields: blocksFields,
+      getFormValues: blocksFormValues,
+    })
+
+    expect(bodies[0]?.get('caption')).toBe('Video caption')
+    expect(bodies[0]?.get('title')).toBe('Hello')
+  })
+
+  it('climbs out of the block to the document root for an upload declared on the block', async () => {
+    // The scope boundary, and the one case that can catch a miscount.
+    //
+    // `poster` sits inside `gallery[]`, so its `../caption` climbs from the
+    // array item to the *block item* — a hop that stays inside the block.
+    // `blockFile` sits on the block itself, so `../title` has to leave the
+    // block and land at the document root.
+    //
+    // Those two behave differently under a path that carries a segment which
+    // addresses nothing. An abandoned experiment qualified instance paths with
+    // the block type (`content[1].videoBlock.blockFile`), and because
+    // `resolveContextPath` counts every dotted segment as one scope,`..`
+    // stopped one level short: `../title` resolved to `content[1].title`
+    // inside the block rather than the root, and arrived empty. The
+    // inside-the-block case absorbed the extra segment and kept passing —
+    // which is exactly why it cannot stand in for this one.
+    const { fn, bodies } = captureUploadField()
+    const uploads = new Map([['content[1].blockFile', pendingUpload()]])
+
+    await executeUploads(uploads, fn, {
+      fields: blocksFields,
+      getFormValues: blocksFormValues,
+    })
+
+    // Root-level `title`, not the block's own `caption` scope.
+    expect(bodies[0]?.get('title')).toBe('Hello')
+    // The sibling still resolves, so a failure above is the climb specifically
+    // and not block resolution having gone wrong generally.
+    expect(bodies[0]?.get('caption')).toBe('Video caption')
+  })
+
   it('still resolves when the addressed block item is missing from form state', async () => {
     // Form state can lag a pending upload. The item is what supplies `_type`,
     // so its absence drops us to the unique-match fallback — but the *field*

package/src/forms/upload-executor.ts

@@ -216,7 +216,10 @@ function resolveContextPath(fieldPath: string, contextPath: string): string | un
   }
 
   // Scope = the upload field's containing segments (dot-split keeps array
-  // indices attached to their segment: `files[2]` stays one hop).
+  // selectors attached to their segment: `files[id=x]` stays one hop).
+  // This relies on every dotted form-path segment being a real data scope. If
+  // the grammar ever adds descriptive/non-navigating segments, classify and
+  // remove them before counting `..` hops rather than changing parent scope.
   const scope = fieldPath.split('.')
   scope.pop() // drop the upload field's own leaf segment