@byline/host-tanstack-start 4.19.0 → 5.0.0

package/src/routes/create-singleton-route.tsx

@@ -10,7 +10,7 @@ import { createFileRoute, notFound } from '@tanstack/react-router'
 import { createServerFn } from '@tanstack/react-start'
 
 import type { DocumentPublishScheduleInfo } from '@byline/client'
-import { getAdminBylineClient, getAdminRequestContext } from '@byline/client/server'
+import { getAdminRequestContext } from '@byline/client/server'
 import {
   buildInitialDataFromFields,
   documentAbilityKey,
@@ -51,6 +51,7 @@ export const getSingletonRouteDocument = createServerFn({ method: 'GET' })
     if (document == null) {
       return {
         document: null,
+        expectedEmpty: true,
         initialData: serialise(
           await buildInitialDataFromFields(definition.fields, {
             locale: data.locale ?? getServerConfig().i18n.content.defaultLocale,
@@ -93,9 +94,9 @@ export const getSingletonRouteDocument = createServerFn({ method: 'GET' })
         actor?.hasAbility(documentAbilityKey(definition, 'changeStatus')) === true &&
         actor.hasAbility(documentAbilityKey(definition, 'publish'))
       if (canSchedulePublication) {
-        scheduledPublish = await getAdminBylineClient()
-          .singleton(data.singleton)
-          .getScheduledPublish()
+        scheduledPublish = (
+          document as unknown as { scheduledPublication: DocumentPublishScheduleInfo | null }
+        ).scheduledPublication
       }
     }
     const serializedSchedule = scheduledPublish == null ? null : serialise(scheduledPublish)
@@ -159,6 +160,7 @@ export function createSingletonRoute(path: string) {
             ]}
           />
           <SingletonView
+            key={`${singleton}/${locale}`}
             singletonDefinition={definition}
             adminConfig={getSingletonAdminConfig(singleton) ?? undefined}
             document={routeState.document}

package/src/server-fns/collections/copy-to-locale.ts

@@ -1,3 +1,4 @@
+import { withDocumentMutationErrors } from '../document-mutation-errors.js'
 /**
  * This Source Code is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -35,6 +36,7 @@ import {
 export const copyDocumentToLocale = createServerFn({ method: 'POST' })
   .validator(
     (input: {
+      expectedRevision: number
       collection: string
       id: string
       sourceLocale: string
@@ -43,43 +45,46 @@ export const copyDocumentToLocale = createServerFn({ method: 'POST' })
     }) => input
   )
   .handler(
-    async ({
-      data: input,
-    }): Promise<CopyToLocaleResult | CollectionDocumentCommittedHookFailureResponse> => {
-      const { collection: path, id, sourceLocale, targetLocale, overwrite } = 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<CopyToLocaleResult | CollectionDocumentCommittedHookFailureResponse> => {
+        const { collection: path, id, sourceLocale, targetLocale, overwrite } = 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 copyToLocale(ctx, {
-          documentId: id,
-          sourceLocale,
-          targetLocale,
-          overwrite,
-        })
-      } catch (error) {
-        const committedFailure = toCommittedDocumentHookFailureResponse(error)
-        if (committedFailure != null) return committedFailure
-        throw error
+        try {
+          return await copyToLocale(ctx, {
+            documentId: id,
+            expectedRevision: input.expectedRevision,
+            sourceLocale,
+            targetLocale,
+            overwrite,
+          })
+        } catch (error) {
+          const committedFailure = toCommittedDocumentHookFailureResponse(error)
+          if (committedFailure != null) return committedFailure
+          throw error
+        }
       }
-    }
+    )
   )

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

@@ -1,3 +1,4 @@
+import { withDocumentMutationErrors } from '../document-mutation-errors.js'
 /**
  * This Source Code is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -30,56 +31,59 @@ export const createCollectionDocument = createServerFn({ method: 'POST' })
       availableLocales?: string[]
     }) => input
   )
-  .handler(async ({ data: input }) => {
-    const {
-      collection: path,
-      data: documentData,
-      locale,
-      path: explicitPath,
-      availableLocales,
-    } = 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(),
-    }
-
-    let result: CreateDocumentResult
-    try {
-      result = await createDocument(ctx, {
-        data: structuredClone(documentData),
-        status: documentData.status,
-        locale: locale ?? serverConfig.i18n.content.defaultLocale,
+  .handler(
+    withDocumentMutationErrors(async ({ data: input }) => {
+      const {
+        collection: path,
+        data: documentData,
+        locale,
         path: explicitPath,
         availableLocales,
-      })
-    } catch (error) {
-      const committedFailure = toCommittedDocumentHookFailureResponse(error)
-      if (committedFailure != null) return committedFailure
-      throw error
-    }
+      } = 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(),
+      }
 
-    // The new document's id is returned so the create view can navigate
-    // straight to the edit view (create → edit).
-    return {
-      status: 'ok' as const,
-      documentId: result.documentId,
-      documentVersionId: result.documentVersionId,
-    }
-  })
+      let result: CreateDocumentResult
+      try {
+        result = await createDocument(ctx, {
+          data: structuredClone(documentData),
+          status: documentData.status,
+          locale: locale ?? serverConfig.i18n.content.defaultLocale,
+          path: explicitPath,
+          availableLocales,
+        })
+      } catch (error) {
+        const committedFailure = toCommittedDocumentHookFailureResponse(error)
+        if (committedFailure != null) return committedFailure
+        throw error
+      }
+
+      // The new document's id is returned so the create view can navigate
+      // straight to the edit view (create → edit).
+      return {
+        status: 'ok' as const,
+        documentId: result.documentId,
+        documentVersionId: result.documentVersionId,
+        revision: result.revision,
+      }
+    })
+  )

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

@@ -1,3 +1,4 @@
+import { withDocumentMutationErrors } from '../document-mutation-errors.js'
 /**
  * This Source Code is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -34,40 +35,48 @@ import {
  * transport layer.
  */
 export const deleteDocumentLocale = createServerFn({ method: 'POST' })
-  .validator((input: { collection: string; id: string; locale: string }) => input)
+  .validator(
+    (input: { expectedRevision: number; collection: string; id: string; locale: string }) => input
+  )
   .handler(
-    async ({
-      data: input,
-    }): Promise<DeleteLocaleResult | CollectionDocumentCommittedHookFailureResponse> => {
-      const { collection: path, id, locale } = 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<DeleteLocaleResult | CollectionDocumentCommittedHookFailureResponse> => {
+        const { collection: path, id, locale } = 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 deleteLocale(ctx, { documentId: id, locale })
-      } catch (error) {
-        const committedFailure = toCommittedDocumentHookFailureResponse(error)
-        if (committedFailure != null) return committedFailure
-        throw error
+        try {
+          return await deleteLocale(ctx, {
+            documentId: id,
+            expectedRevision: input.expectedRevision,
+            locale,
+          })
+        } catch (error) {
+          const committedFailure = toCommittedDocumentHookFailureResponse(error)
+          if (committedFailure != null) return committedFailure
+          throw error
+        }
       }
-    }
+    )
   )

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

@@ -1,3 +1,4 @@
+import { withDocumentMutationErrors } from '../document-mutation-errors.js'
 /**
  * This Source Code is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -21,43 +22,48 @@ 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)
-    }
+  .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

@@ -1,3 +1,4 @@
+import { withDocumentMutationErrors } from '../document-mutation-errors.js'
 /**
  * This Source Code is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -35,40 +36,45 @@ 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)
+  .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

@@ -1,3 +1,4 @@
+import { withEditableRevision } from '../editable-revision.js'
 /**
  * This Source Code is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -51,13 +52,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 +145,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 }