@byline/host-tanstack-start 4.19.0 → 5.1.0

package/src/server-fns/collections/delete-outcome.test.node.ts

@@ -16,6 +16,10 @@ describe('delete outcome transport and admin interpretation', () => {
     // Simulate malformed runtime data from an older or compromised source. The
     // core type rejects this shape, but the transport still sanitizes it.
     const unsafeResult = {
+      documentId: 'doc-1',
+      revision: 2,
+      affectedDocuments: [{ documentId: 'child', revision: 3 }],
+      scheduledPublicationsNeedReconfirmation: true,
       deletedVersionCount: 2,
       outcome: 'committed-with-side-effect-failures',
       sideEffectFailures: [
@@ -36,6 +40,10 @@ describe('delete outcome transport and admin interpretation', () => {
 
     expect(response).toEqual({
       status: 'ok',
+      documentId: 'doc-1',
+      revision: 2,
+      affectedDocuments: [{ documentId: 'child', revision: 3 }],
+      scheduledPublicationsNeedReconfirmation: true,
       deletedVersionCount: 2,
       outcome: 'committed-with-side-effect-failures',
       sideEffectFailures: [
@@ -53,6 +61,10 @@ describe('delete outcome transport and admin interpretation', () => {
 
   it('preserves the committed success discriminant and empty failures', () => {
     const response = toDeleteDocumentResponse({
+      documentId: 'doc-1',
+      revision: 2,
+      affectedDocuments: [{ documentId: 'child', revision: 3 }],
+      scheduledPublicationsNeedReconfirmation: true,
       deletedVersionCount: 2,
       outcome: 'committed',
       sideEffectFailures: [],
@@ -60,6 +72,10 @@ describe('delete outcome transport and admin interpretation', () => {
 
     expect(response).toEqual({
       status: 'ok',
+      documentId: 'doc-1',
+      revision: 2,
+      affectedDocuments: [{ documentId: 'child', revision: 3 }],
+      scheduledPublicationsNeedReconfirmation: true,
       deletedVersionCount: 2,
       outcome: 'committed',
       sideEffectFailures: [],

package/src/server-fns/collections/delete-outcome.ts

@@ -10,6 +10,7 @@ import type {
   DeleteDocumentResult,
   DeleteDocumentSideEffectCode,
   DeleteDocumentSideEffectPhase,
+  StructuralMutationReceipt,
 } from '@byline/core'
 import { ErrorCodes } from '@byline/core'
 
@@ -21,22 +22,28 @@ export interface DeleteDocumentPublicSideEffectFailure {
   code: DeleteDocumentPublicSideEffectCode
 }
 
-export type DeleteDocumentResponse =
-  | {
-      status: 'ok'
-      deletedVersionCount: number
-      outcome: 'committed'
-      sideEffectFailures: []
-    }
-  | {
-      status: 'ok'
-      deletedVersionCount: number
-      outcome: 'committed-with-side-effect-failures'
-      sideEffectFailures: [
-        DeleteDocumentPublicSideEffectFailure,
-        ...DeleteDocumentPublicSideEffectFailure[],
-      ]
-    }
+export type DeleteDocumentResponse = StructuralMutationReceipt &
+  (
+    | {
+        status: 'ok'
+        documentId: string
+        revision: number
+        deletedVersionCount: number
+        outcome: 'committed'
+        sideEffectFailures: []
+      }
+    | {
+        status: 'ok'
+        documentId: string
+        revision: number
+        deletedVersionCount: number
+        outcome: 'committed-with-side-effect-failures'
+        sideEffectFailures: [
+          DeleteDocumentPublicSideEffectFailure,
+          ...DeleteDocumentPublicSideEffectFailure[],
+        ]
+      }
+  )
 
 function sanitizePhase(phase: DeleteDocumentSideEffectPhase): DeleteDocumentPublicSideEffectPhase {
   if (phase === 'afterTreeChange' || phase === 'afterDelete') {
@@ -67,6 +74,10 @@ export function toDeleteDocumentResponse(result: DeleteDocumentResult): DeleteDo
   const [firstFailure, ...remainingFailures] = result.sideEffectFailures
   return {
     status: 'ok',
+    documentId: result.documentId,
+    revision: result.revision,
+    affectedDocuments: result.affectedDocuments,
+    scheduledPublicationsNeedReconfirmation: result.scheduledPublicationsNeedReconfirmation,
     deletedVersionCount: result.deletedVersionCount,
     outcome: result.outcome,
     sideEffectFailures: [sanitizeFailure(firstFailure), ...remainingFailures.map(sanitizeFailure)],

package/src/server-fns/collections/delete.ts

@@ -14,6 +14,8 @@ import type { DocumentLifecycleContext } from '@byline/core/services'
 import { deleteDocument as deleteDocumentService } from '@byline/core/services'
 
 import { ensureCollection } from '../../integrations/api-utils.js'
+import { adminSessionMiddleware } from '../../integrations/session-middleware.js'
+import { withDocumentMutationErrors } from '../document-mutation-errors.js'
 import { toDeleteDocumentResponse } from './delete-outcome.js'
 
 // ---------------------------------------------------------------------------
@@ -21,43 +23,49 @@ import { toDeleteDocumentResponse } from './delete-outcome.js'
 // ---------------------------------------------------------------------------
 
 export const deleteDocument = createServerFn({ method: 'POST' })
-  .validator((input: { collection: string; id: string }) => input)
-  .handler(async ({ data: input }) => {
-    const { collection: path, id } = input
-    const logger = getLogger()
-    const config = await ensureCollection(path)
-    if (!config) {
-      throw ERR_NOT_FOUND({
-        message: 'Collection not found',
-        details: { collectionPath: path },
-      }).log(logger)
-    }
+  .middleware([adminSessionMiddleware])
+  .validator((input: { expectedRevision: number; collection: string; id: string }) => input)
+  .handler(
+    withDocumentMutationErrors(async ({ data: input }) => {
+      const { collection: path, id } = input
+      const logger = getLogger()
+      const config = await ensureCollection(path)
+      if (!config) {
+        throw ERR_NOT_FOUND({
+          message: 'Collection not found',
+          details: { collectionPath: path },
+        }).log(logger)
+      }
 
-    const serverConfig = getServerConfig()
-    // Resolve the storage provider so the lifecycle service can clean up
-    // uploaded files and variants on deletion. With per-field upload
-    // config, a collection may have one (or more) image/file fields with
-    // their own storage. The delete path needs *a* provider; we pick the
-    // first upload-capable field's, falling back to the site-wide
-    // default. Multi-storage collections are out of scope today —
-    // deletion routes everything through one provider, which is fine
-    // when all upload fields target the same backend (the common case).
-    const firstUploadField = getUploadFields(config.definition)[0]
-    const storage = firstUploadField?.upload?.storage ?? serverConfig.storage
-    const db = serverConfig.db
-    const ctx: DocumentLifecycleContext = {
-      db,
-      definition: config.definition,
-      collectionId: config.collection.id,
-      collectionVersion: config.collection.version,
-      collectionPath: path,
-      ...(storage ? { storage } : {}),
-      logger,
-      defaultLocale: serverConfig.i18n.content.defaultLocale,
-      slugifier: serverConfig.slugifier,
-      requestContext: await getAdminRequestContext(),
-    }
+      const serverConfig = getServerConfig()
+      // Resolve the storage provider so the lifecycle service can clean up
+      // uploaded files and variants on deletion. With per-field upload
+      // config, a collection may have one (or more) image/file fields with
+      // their own storage. The delete path needs *a* provider; we pick the
+      // first upload-capable field's, falling back to the site-wide
+      // default. Multi-storage collections are out of scope today —
+      // deletion routes everything through one provider, which is fine
+      // when all upload fields target the same backend (the common case).
+      const firstUploadField = getUploadFields(config.definition)[0]
+      const storage = firstUploadField?.upload?.storage ?? serverConfig.storage
+      const db = serverConfig.db
+      const ctx: DocumentLifecycleContext = {
+        db,
+        definition: config.definition,
+        collectionId: config.collection.id,
+        collectionVersion: config.collection.version,
+        collectionPath: path,
+        ...(storage ? { storage } : {}),
+        logger,
+        defaultLocale: serverConfig.i18n.content.defaultLocale,
+        slugifier: serverConfig.slugifier,
+        requestContext: await getAdminRequestContext(),
+      }
 
-    const result = await deleteDocumentService(ctx, { documentId: id })
-    return toDeleteDocumentResponse(result)
-  })
+      const result = await deleteDocumentService(ctx, {
+        documentId: id,
+        expectedRevision: input.expectedRevision,
+      })
+      return toDeleteDocumentResponse(result)
+    })
+  )

package/src/server-fns/collections/duplicate.ts

@@ -14,6 +14,8 @@ import type { DocumentLifecycleContext, DuplicateDocumentResult } from '@byline/
 import { duplicateDocument } from '@byline/core/services'
 
 import { ensureCollection } from '../../integrations/api-utils.js'
+import { adminSessionMiddleware } from '../../integrations/session-middleware.js'
+import { withDocumentMutationErrors } from '../document-mutation-errors.js'
 import {
   type CollectionDocumentCommittedHookFailureResponse,
   toCommittedDocumentHookFailureResponse,
@@ -35,40 +37,46 @@ import {
  * TanStack Start's transport layer for the client to branch on.
  */
 export const duplicateCollectionDocument = createServerFn({ method: 'POST' })
-  .validator((input: { collection: string; id: string }) => input)
+  .middleware([adminSessionMiddleware])
+  .validator((input: { expectedRevision: number; collection: string; id: string }) => input)
   .handler(
-    async ({
-      data: input,
-    }): Promise<DuplicateDocumentResult | CollectionDocumentCommittedHookFailureResponse> => {
-      const { collection: path, id: sourceDocumentId } = input
-      const logger = getLogger()
-      const config = await ensureCollection(path)
-      if (!config) {
-        throw ERR_NOT_FOUND({
-          message: 'Collection not found',
-          details: { collectionPath: path },
-        }).log(logger)
-      }
+    withDocumentMutationErrors(
+      async ({
+        data: input,
+      }): Promise<DuplicateDocumentResult | CollectionDocumentCommittedHookFailureResponse> => {
+        const { collection: path, id: sourceDocumentId } = input
+        const logger = getLogger()
+        const config = await ensureCollection(path)
+        if (!config) {
+          throw ERR_NOT_FOUND({
+            message: 'Collection not found',
+            details: { collectionPath: path },
+          }).log(logger)
+        }
 
-      const serverConfig = getServerConfig()
-      const ctx: DocumentLifecycleContext = {
-        db: serverConfig.db,
-        definition: config.definition,
-        collectionId: config.collection.id,
-        collectionVersion: config.collection.version,
-        collectionPath: path,
-        logger,
-        defaultLocale: serverConfig.i18n.content.defaultLocale,
-        slugifier: serverConfig.slugifier,
-        requestContext: await getAdminRequestContext(),
-      }
+        const serverConfig = getServerConfig()
+        const ctx: DocumentLifecycleContext = {
+          db: serverConfig.db,
+          definition: config.definition,
+          collectionId: config.collection.id,
+          collectionVersion: config.collection.version,
+          collectionPath: path,
+          logger,
+          defaultLocale: serverConfig.i18n.content.defaultLocale,
+          slugifier: serverConfig.slugifier,
+          requestContext: await getAdminRequestContext(),
+        }
 
-      try {
-        return await duplicateDocument(ctx, { sourceDocumentId })
-      } catch (error) {
-        const committedFailure = toCommittedDocumentHookFailureResponse(error)
-        if (committedFailure != null) return committedFailure
-        throw error
+        try {
+          return await duplicateDocument(ctx, {
+            sourceDocumentId,
+            expectedRevision: input.expectedRevision,
+          })
+        } catch (error) {
+          const committedFailure = toCommittedDocumentHookFailureResponse(error)
+          if (committedFailure != null) return committedFailure
+          throw error
+        }
       }
-    }
+    )
   )

package/src/server-fns/collections/get.ts

@@ -20,7 +20,9 @@ import {
 } from '@byline/core'
 
 import { ensureCollection } from '../../integrations/api-utils.js'
+import { adminSessionMiddleware } from '../../integrations/session-middleware.js'
 import { resolveAdminDocumentRead } from '../admin-document-presentation.js'
+import { withEditableRevision } from '../editable-revision.js'
 import { serialise } from './utils'
 
 // ---------------------------------------------------------------------------
@@ -28,6 +30,7 @@ import { serialise } from './utils'
 // ---------------------------------------------------------------------------
 
 const getDocumentFn = createServerFn({ method: 'GET' })
+  .middleware([adminSessionMiddleware])
   .validator(
     (input: {
       collection: string
@@ -51,13 +54,16 @@ const getDocumentFn = createServerFn({ method: 'GET' })
     const client = getAdminBylineClient()
     const handle = client.collection(path)
 
-    const { options: readOptions, populatedTree } = resolveAdminDocumentRead(config.definition, {
+    const {
+      options: { status: _status, ...readOptions },
+      populatedTree,
+    } = resolveAdminDocumentRead(config.definition, {
       locale,
       depth,
       populateRelations,
     })
 
-    const document = await handle.findById(id, {
+    const document = await handle.findByIdForEdit(id, {
       ...readOptions,
     })
 
@@ -141,13 +147,13 @@ const getDocumentFn = createServerFn({ method: 'GET' })
         actor?.hasAbility(documentAbilityKey(config.definition, 'changeStatus')) === true &&
         actor.hasAbility(documentAbilityKey(config.definition, 'publish'))
       if (canSchedulePublication) {
-        scheduledPublish = await handle.getScheduledPublish(id)
+        scheduledPublish = document.scheduledPublication
       }
     }
     const serializedSchedule = scheduledPublish == null ? null : serialise(scheduledPublish)
 
     return {
-      ...(parsed as Record<string, any>),
+      ...withEditableRevision(parsed, document),
       _publishedVersion: publishedVersion,
       ...(restoreWarnings && restoreWarnings.length > 0
         ? { _restoreWarnings: restoreWarnings }
@@ -173,6 +179,7 @@ const getDocumentFn = createServerFn({ method: 'GET' })
 // ---------------------------------------------------------------------------
 
 const getDocumentByVersionFn = createServerFn({ method: 'GET' })
+  .middleware([adminSessionMiddleware])
   .validator((input: { collection: string; versionId: string; locale?: string }) => input)
   .handler(async ({ data }) => {
     const { collection: path, versionId, locale } = data

package/src/server-fns/collections/history.ts

@@ -12,6 +12,7 @@ import { getAdminBylineClient } from '@byline/client/server'
 import { ERR_NOT_FOUND, getCollectionSchemasForPath, getLogger } from '@byline/core'
 
 import { ensureCollection } from '../../integrations/api-utils.js'
+import { adminSessionMiddleware } from '../../integrations/session-middleware.js'
 import { type ActorLabelMap, resolveActorLabels } from './actors.js'
 import { serialise } from './utils'
 
@@ -32,6 +33,7 @@ export interface HistorySearchParams {
 // ---------------------------------------------------------------------------
 
 export const getCollectionDocumentHistory = createServerFn({ method: 'GET' })
+  .middleware([adminSessionMiddleware])
   .validator((input: { collection: string; id: string; params: HistorySearchParams }) => input)
   .handler(async ({ data }) => {
     const { collection: path, id, params } = data

package/src/server-fns/collections/list.ts

@@ -24,6 +24,8 @@ import {
 
 import { ensureCollection } from '../../integrations/api-utils.js'
 import { bylineCore } from '../../integrations/byline-core.js'
+import { adminSessionMiddleware } from '../../integrations/session-middleware.js'
+import { withEditableRevision } from '../editable-revision.js'
 import { resolveListViewState, sortableFieldNames } from './list-view-state.js'
 import { serialise } from './utils'
 import type { ListViewPreferenceValue } from './list-view-state.js'
@@ -48,6 +50,7 @@ export interface CollectionSearchParams {
 // ---------------------------------------------------------------------------
 
 export const getCollectionDocuments = createServerFn({ method: 'GET' })
+  .middleware([adminSessionMiddleware])
   .validator((input: { collection: string; params: CollectionSearchParams }) => input)
   .handler(async ({ data }) => {
     const { collection: path, params } = data
@@ -131,7 +134,7 @@ export const getCollectionDocuments = createServerFn({ method: 'GET' })
     const hasRelations = Object.keys(populateMap).length > 0
     const populate: PopulateSpec | undefined = hasRelations ? populateMap : undefined
 
-    const result = await handle.find({
+    const result = await handle.findForEdit({
       where: Object.keys(where).length > 0 ? where : undefined,
       sort: viewState.sort,
       locale: params.locale ?? 'en',
@@ -140,7 +143,6 @@ export const getCollectionDocuments = createServerFn({ method: 'GET' })
       select: params.fields,
       populate,
       depth: hasRelations ? 1 : undefined,
-      status: 'any',
       // Admin list: show the raw per-locale state (untranslated docs render
       // empty in the active locale's columns) rather than falling back to the
       // default locale. Consistent with the edit view; overrides the client's
@@ -205,5 +207,10 @@ export const getCollectionDocuments = createServerFn({ method: 'GET' })
       return serialised as unknown as ReturnType<typeof list.parse>
     }
 
-    return list.parse(serialised)
+    const parsed = list.parse(serialised)
+    const observations = new Map(result.docs.map((doc) => [doc.id, doc]))
+    return {
+      ...parsed,
+      docs: parsed.docs.map((doc) => withEditableRevision(doc, observations.get(doc.id))),
+    }
   })

package/src/server-fns/collections/reindex.ts

@@ -26,10 +26,12 @@ import { getAdminBylineClient } from '@byline/client/server'
 import { ERR_NOT_FOUND, getLogger } from '@byline/core'
 
 import { ensureCollection } from '../../integrations/api-utils.js'
+import { adminSessionMiddleware } from '../../integrations/session-middleware.js'
 
 export type { ReindexResult }
 
 export const reindexCollection = createServerFn({ method: 'POST' })
+  .middleware([adminSessionMiddleware])
   .validator((input: { collection: string }) => input)
   .handler(async ({ data }): Promise<ReindexResult> => {
     const { collection } = data

package/src/server-fns/collections/reorder.ts

@@ -9,17 +9,11 @@
 import { createServerFn } from '@tanstack/react-start'
 
 import { getAdminRequestContext } from '@byline/client/server'
-import {
-  assertActorCanPerform,
-  ERR_NOT_FOUND,
-  ERR_VALIDATION,
-  generateKeyBetween,
-  generateNKeysBetween,
-  getLogger,
-  getServerConfig,
-} from '@byline/core'
+import { ERR_NOT_FOUND, getLogger, getServerConfig, reorderDocument } from '@byline/core'
 
 import { ensureCollection } from '../../integrations/api-utils.js'
+import { adminSessionMiddleware } from '../../integrations/session-middleware.js'
+import { withDocumentMutationErrors } from '../document-mutation-errors.js'
 
 // ---------------------------------------------------------------------------
 // Reorder a single document within an `orderable: true` collection.
@@ -27,138 +21,54 @@ import { ensureCollection } from '../../integrations/api-utils.js'
 // One of `beforeDocumentId` / `afterDocumentId` should be provided — they
 // identify the neighbours the dragged row should land between. Either may
 // be null:
-//   - both null    → empty collection or "append-to-end" no-op (writes
-//                     a fresh key)
+//   - both null    → append to the end; retain the key if already there
 //   - beforeId set, afterId null   → append after `beforeId`
 //   - beforeId null, afterId set   → prepend before `afterId`
 //
-// Writes a single column on `byline_documents` and does NOT create a new
-// document version. Goes through the `collections.<path>.update` ability;
+// Updates ordering and any necessary sibling-key repairs in one guarded
+// transaction, without creating content versions. Uses `collections.<path>.update`;
 // reordering is metadata-level update, not a new ability slug.
 // ---------------------------------------------------------------------------
 
 export const reorderCollectionDocument = createServerFn({ method: 'POST' })
+  .middleware([adminSessionMiddleware])
   .validator(
     (input: {
+      expectedRevision: number
       collection: string
       documentId: string
       beforeDocumentId?: string | null
       afterDocumentId?: string | null
     }) => input
   )
-  .handler(async ({ data: input }) => {
-    const { collection: path, documentId, beforeDocumentId, afterDocumentId } = input
-    const logger = getLogger()
-
-    const config = await ensureCollection(path)
-    if (!config) {
-      throw ERR_NOT_FOUND({
-        message: 'Collection not found',
-        details: { collectionPath: path },
-      }).log(logger)
-    }
-
-    if (config.definition.orderable !== true) {
-      throw ERR_VALIDATION({
-        message: `collection '${path}' is not orderable; set \`orderable: true\` on its collection definition to enable reordering`,
-        details: { collectionPath: path },
-      }).log(logger)
-    }
-
-    const requestContext = await getAdminRequestContext()
-    assertActorCanPerform(requestContext, config.definition, 'update')
-
-    const serverConfig = getServerConfig()
-    const collectionId = config.collection.id
-
-    // Read the whole collection in canonical display order. Small by design
-    // for orderable use cases (bios, FAQs, sections), so a full read is
-    // cheap — and it gives us a single, consistent snapshot to reason about
-    // both backfill and recovery in one pass.
-    const canonical = await serverConfig.db.queries.documents.getCanonicalDocumentOrder({
-      collection_id: collectionId,
-    })
-
-    // Detect pathological key state — duplicates or non-ascending runs of
-    // keyed rows. These can land in the DB from prior buggy code paths
-    // or interrupted writes; once present, `generateKeyBetween` throws
-    // with `a >= b`. When detected, re-key the entire collection in the
-    // editor's current visible order so subsequent operations work from
-    // a clean baseline.
-    let corrupted = false
-    {
-      const seen = new Set<string>()
-      let lastKey: string | null = null
-      for (const doc of canonical) {
-        if (doc.order_key == null) continue
-        if (seen.has(doc.order_key)) {
-          corrupted = true
-          break
-        }
-        if (lastKey != null && doc.order_key <= lastKey) {
-          corrupted = true
-          break
-        }
-        seen.add(doc.order_key)
-        lastKey = doc.order_key
+  .handler(
+    withDocumentMutationErrors(async ({ data: input }) => {
+      const { collection: path, documentId, beforeDocumentId, afterDocumentId } = input
+      const logger = getLogger()
+
+      const config = await ensureCollection(path)
+      if (!config) {
+        throw ERR_NOT_FOUND({
+          message: 'Collection not found',
+          details: { collectionPath: path },
+        }).log(logger)
       }
-    }
 
-    if (corrupted) {
-      const allKeys = generateNKeysBetween(null, null, canonical.length)
-      for (let i = 0; i < canonical.length; i++) {
-        await serverConfig.db.commands.documents.setOrderKey({
-          document_id: canonical[i]?.id,
-          order_key: allKeys[i]!,
-        })
-      }
-    } else {
-      // Happy path — backfill trailing NULLs after the largest existing
-      // key. After canonical sort the NULL rows are always contiguous at
-      // the tail (`NULLS LAST`).
-      const firstNullIdx = canonical.findIndex((d) => d.order_key == null)
-      if (firstNullIdx !== -1) {
-        const nullDocs = canonical.slice(firstNullIdx)
-        const lastExistingKey = firstNullIdx === 0 ? null : canonical[firstNullIdx - 1]?.order_key
-        const newKeys = generateNKeysBetween(lastExistingKey, null, nullDocs.length)
-        for (let i = 0; i < nullDocs.length; i++) {
-          await serverConfig.db.commands.documents.setOrderKey({
-            document_id: nullDocs[i]?.id,
-            order_key: newKeys[i]!,
-          })
-        }
-      }
-    }
-
-    // Keys are now clean — resolve neighbours and place the moved row.
-    const { left, right } = await serverConfig.db.queries.documents.getNeighborOrderKeys({
-      collection_id: collectionId,
-      before_document_id: beforeDocumentId ?? null,
-      after_document_id: afterDocumentId ?? null,
-    })
-
-    let newKey: string
-    try {
-      newKey = generateKeyBetween(left, right)
-    } catch (err) {
-      throw ERR_VALIDATION({
-        message: 'cannot generate order_key between supplied neighbors',
-        details: {
+      const serverConfig = getServerConfig()
+      const result = await reorderDocument(
+        {
+          db: serverConfig.db,
+          definition: config.definition,
+          collectionId: config.collection.id,
+          collectionVersion: config.collection.version,
           collectionPath: path,
-          documentId,
-          beforeDocumentId,
-          afterDocumentId,
-          left,
-          right,
-          cause: err instanceof Error ? err.message : String(err),
+          requestContext: await getAdminRequestContext(),
+          logger,
+          defaultLocale: serverConfig.i18n.content.defaultLocale,
+          slugifier: serverConfig.slugifier,
         },
-      }).log(logger)
-    }
-
-    await serverConfig.db.commands.documents.setOrderKey({
-      document_id: documentId,
-      order_key: newKey,
+        { documentId, expectedRevision: input.expectedRevision, beforeDocumentId, afterDocumentId }
+      )
+      return { status: 'ok' as const, ...result }
     })
-
-    return { status: 'ok' as const, orderKey: newKey }
-  })
+  )