@byline/host-tanstack-start 4.18.0 → 4.19.0

package/src/admin-shell/collections/save-navigation.test.tsx

@@ -0,0 +1,384 @@
+/**
+ * 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
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import type React from 'react'
+import { act } from 'react'
+
+import { type MultiCollectionDefinition, SINGLE_STATUS_WORKFLOW } from '@byline/core'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  copyToLocale: vi.fn(),
+  create: vi.fn(),
+  deleteLocale: vi.fn(),
+  duplicate: vi.fn(),
+  navigate: vi.fn(),
+  formProps: [] as Array<Record<string, unknown>>,
+  toastAdd: vi.fn(),
+  update: vi.fn(),
+  updateSystemFields: vi.fn(),
+}))
+
+vi.mock('@byline/admin/react', () => ({
+  FormRenderer: (props: Record<string, unknown>) => {
+    mocks.formProps.push(props)
+    return <div data-testid="form-renderer" />
+  },
+}))
+
+vi.mock('@byline/i18n/react', () => ({
+  useTranslation: () => ({
+    t: (key: string) => key,
+  }),
+}))
+
+vi.mock('@byline/ui/react', () => {
+  const Pass = ({ children }: { children?: React.ReactNode }) => <div>{children}</div>
+  return {
+    Container: Pass,
+    Section: Pass,
+    useToastManager: () => ({ add: mocks.toastAdd }),
+  }
+})
+
+vi.mock('../../routes/admin-path.js', () => ({
+  getAdminRoutePath: (...parts: string[]) => `/admin/${parts.join('/')}`,
+}))
+
+vi.mock('../../routes/list-return-state.js', () => ({
+  decodeListReturnState: () => ({ page: 2 }),
+}))
+
+vi.mock('../../routes/list-return-storage.js', () => ({
+  clearListReturnState: vi.fn(),
+}))
+
+vi.mock('../../server-fns/collections/index.js', () => ({
+  cancelCollectionDocumentScheduledPublish: vi.fn(),
+  confirmCollectionDocumentScheduledPublish: vi.fn(),
+  copyDocumentToLocale: mocks.copyToLocale,
+  createCollectionDocument: mocks.create,
+  deleteDocument: vi.fn(),
+  deleteDocumentLocale: mocks.deleteLocale,
+  duplicateCollectionDocument: mocks.duplicate,
+  hasCommittedDocumentHookFailure: (result: { status: string }) =>
+    result.status === 'committed-hook-failed',
+  hasDeleteSideEffectFailures: () => false,
+  scheduleCollectionDocumentPublish: vi.fn(),
+  unpublishDocument: vi.fn(),
+  updateCollectionDocumentSystemFields: mocks.updateSystemFields,
+  updateCollectionDocumentWithPatches: mocks.update,
+  updateDocumentStatus: vi.fn(),
+}))
+
+vi.mock('../chrome/loose-router.js', () => ({
+  useNavigate: () => mocks.navigate,
+}))
+
+vi.mock('./tanstack-navigation-guard.js', () => ({
+  useTanStackNavigationGuard: () => ({
+    isBlocked: false,
+    stay: () => {},
+    proceed: () => {},
+  }),
+}))
+
+vi.mock('./view-menu.js', () => ({
+  ViewMenu: () => null,
+}))
+
+import { CreateView } from './create.js'
+import { EditView } from './edit.js'
+
+const collection = {
+  path: 'languages',
+  labels: { singular: 'Language', plural: 'Languages' },
+  workflow: SINGLE_STATUS_WORKFLOW,
+  fields: [{ name: 'name', label: 'Name', type: 'text' }],
+} as MultiCollectionDefinition
+
+const initialData = {
+  id: 'language-en',
+  versionId: 'version-1',
+  status: 'published',
+  fields: { name: 'English' },
+}
+
+let container: HTMLDivElement
+let root: Root
+
+beforeAll(() => {
+  ;(
+    globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }
+  ).IS_REACT_ACT_ENVIRONMENT = true
+})
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mocks.formProps.length = 0
+  mocks.create.mockResolvedValue({
+    status: 'ok',
+    documentId: 'language-th',
+    documentVersionId: 'version-created',
+  })
+  mocks.update.mockResolvedValue({ status: 'ok' })
+  mocks.updateSystemFields.mockResolvedValue({ status: 'ok' })
+  mocks.copyToLocale.mockResolvedValue({
+    documentId: 'language-en',
+    documentVersionId: 'version-2',
+    sourceLocale: 'en',
+    targetLocale: 'th',
+    fieldsUpdated: 1,
+  })
+  mocks.deleteLocale.mockResolvedValue({
+    documentId: 'language-en',
+    documentVersionId: 'version-2',
+    locale: 'th',
+  })
+  mocks.duplicate.mockResolvedValue({
+    documentId: 'language-copy',
+    documentVersionId: 'version-copy',
+    sourceDocumentId: 'language-en',
+    newPath: 'english-copy',
+    pathRetried: false,
+  })
+  container = document.createElement('div')
+  document.body.appendChild(container)
+  root = createRoot(container)
+})
+
+afterEach(() => {
+  act(() => root.unmount())
+  container.remove()
+})
+
+afterAll(() => {
+  delete (globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean })
+    .IS_REACT_ACT_ENVIRONMENT
+})
+
+function latestSubmit(): (payload: Record<string, unknown>) => Promise<void> {
+  const onSubmit = mocks.formProps.at(-1)?.onSubmit
+  if (typeof onSubmit !== 'function') throw new Error('FormRenderer onSubmit not found')
+  return onSubmit as (payload: Record<string, unknown>) => Promise<void>
+}
+
+function latestAction(name: string): (...args: any[]) => Promise<void> {
+  const action = mocks.formProps.at(-1)?.[name]
+  if (typeof action !== 'function') throw new Error(`FormRenderer ${name} not found`)
+  return action as (...args: any[]) => Promise<void>
+}
+
+describe('collection post-save navigation', () => {
+  it('bypasses the dirty-form blocker when create redirects to the new document', async () => {
+    act(() => {
+      root.render(<CreateView collectionDefinition={collection} from="page=2" />)
+    })
+
+    await act(async () => {
+      await latestSubmit()({ data: { name: 'Thai' } })
+    })
+
+    expect(mocks.navigate).toHaveBeenCalledWith({
+      to: '/admin/collections/$collection/$id',
+      params: { collection: 'languages', id: 'language-th' },
+      search: { action: 'created', from: 'page=2' },
+      ignoreBlocker: true,
+    })
+  })
+
+  it('bypasses the dirty-form blocker when create falls back to the list', async () => {
+    mocks.create.mockResolvedValueOnce({ status: 'ok' })
+    act(() => {
+      root.render(<CreateView collectionDefinition={collection} from="page=2" />)
+    })
+
+    await act(async () => {
+      await latestSubmit()({ data: { name: 'Thai' } })
+    })
+
+    expect(mocks.navigate).toHaveBeenCalledWith({
+      to: '/admin/collections/$collection',
+      params: { collection: 'languages' },
+      search: { page: 2, action: 'created' },
+      ignoreBlocker: true,
+    })
+  })
+
+  it('does not bypass the blocker or navigate when create fails', async () => {
+    const error = new Error('create failed')
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+    mocks.create.mockRejectedValueOnce(error)
+    act(() => {
+      root.render(<CreateView collectionDefinition={collection} />)
+    })
+
+    await expect(latestSubmit()({ data: { name: 'Thai' } })).rejects.toBe(error)
+
+    expect(mocks.navigate).not.toHaveBeenCalled()
+    consoleError.mockRestore()
+  })
+
+  it('treats a committed create hook failure as saved and navigates with a warning', async () => {
+    mocks.create.mockResolvedValueOnce({
+      status: 'committed-hook-failed',
+      documentId: 'language-th',
+      documentVersionId: 'version-created',
+      sideEffectFailure: { phase: 'afterCreate', code: 'ERR_UNHANDLED' },
+    })
+    act(() => {
+      root.render(<CreateView collectionDefinition={collection} from="page=2" />)
+    })
+
+    await act(async () => {
+      await latestSubmit()({ data: { name: 'Thai' } })
+    })
+
+    expect(mocks.toastAdd).toHaveBeenCalledWith({
+      title: 'collections.save.hookFailedToast',
+      description: 'collections.save.hookFailedDescription',
+      data: { intent: 'warning', iconType: 'warning', icon: true, close: true },
+    })
+    expect(mocks.navigate).toHaveBeenCalledWith({
+      to: '/admin/collections/$collection/$id',
+      params: { collection: 'languages', id: 'language-th' },
+      search: { from: 'page=2' },
+      ignoreBlocker: true,
+    })
+  })
+
+  it('bypasses the dirty-form blocker during the successful edit refresh', async () => {
+    act(() => {
+      root.render(
+        <EditView
+          collectionDefinition={collection}
+          initialData={initialData as never}
+          contentLocales={[{ code: 'en', label: 'English' }]}
+          defaultContentLocale="en"
+          locale="en"
+        />
+      )
+    })
+
+    await act(async () => {
+      await latestSubmit()({
+        data: { name: 'English' },
+        patches: [{ kind: 'field.set', path: 'name', value: 'English' }],
+        contentDirty: true,
+        pathDirty: false,
+        availableLocalesDirty: false,
+      })
+    })
+
+    expect(mocks.navigate).toHaveBeenCalledWith({
+      to: '/admin/collections/$collection/$id',
+      params: { collection: 'languages', id: 'language-en' },
+      search: expect.any(Function),
+      ignoreBlocker: true,
+    })
+  })
+
+  it('treats a committed update hook failure as saved and refreshes with a warning', async () => {
+    mocks.update.mockResolvedValueOnce({
+      status: 'committed-hook-failed',
+      documentId: 'language-en',
+      documentVersionId: 'version-2',
+      sideEffectFailure: { phase: 'afterUpdate', code: 'ERR_UNHANDLED' },
+    })
+    act(() => {
+      root.render(
+        <EditView
+          collectionDefinition={collection}
+          initialData={initialData as never}
+          contentLocales={[{ code: 'en', label: 'English' }]}
+          defaultContentLocale="en"
+          locale="en"
+        />
+      )
+    })
+
+    await act(async () => {
+      await latestSubmit()({
+        data: { name: 'English' },
+        patches: [{ kind: 'field.set', path: 'name', value: 'English' }],
+        contentDirty: true,
+        pathDirty: false,
+        availableLocalesDirty: false,
+      })
+    })
+
+    expect(mocks.toastAdd).toHaveBeenCalledWith({
+      title: 'collections.save.hookFailedToast',
+      description: 'collections.save.hookFailedDescription',
+      data: { intent: 'warning', iconType: 'warning', icon: true, close: true },
+    })
+    expect(mocks.navigate).toHaveBeenCalledWith(expect.objectContaining({ ignoreBlocker: true }))
+  })
+
+  it.each([
+    {
+      action: 'onDuplicate',
+      invoke: () => latestAction('onDuplicate')(),
+      mock: mocks.duplicate,
+      phase: 'afterCreate',
+      expectedSearch: expect.any(Function),
+      expectedId: 'language-copy',
+    },
+    {
+      action: 'onCopyToLocale',
+      invoke: () => latestAction('onCopyToLocale')({ targetLocale: 'th', overwrite: false }),
+      mock: mocks.copyToLocale,
+      phase: 'afterUpdate',
+      expectedSearch: expect.any(Function),
+      expectedId: 'language-en',
+    },
+    {
+      action: 'onDeleteLocale',
+      invoke: () => latestAction('onDeleteLocale')({ targetLocale: 'th' }),
+      mock: mocks.deleteLocale,
+      phase: 'afterUpdate',
+      expectedSearch: expect.any(Function),
+      expectedId: 'language-en',
+    },
+  ])('treats committed $action hook failures as completed mutations', async (testCase) => {
+    testCase.mock.mockResolvedValueOnce({
+      status: 'committed-hook-failed',
+      documentId: testCase.expectedId,
+      documentVersionId: 'version-committed',
+      sideEffectFailure: { phase: testCase.phase, code: 'ERR_UNHANDLED' },
+    })
+    act(() => {
+      root.render(
+        <EditView
+          collectionDefinition={collection}
+          initialData={initialData as never}
+          contentLocales={[
+            { code: 'en', label: 'English' },
+            { code: 'th', label: 'Thai' },
+          ]}
+          defaultContentLocale="en"
+          locale="en"
+        />
+      )
+    })
+
+    await act(testCase.invoke)
+
+    expect(mocks.toastAdd).toHaveBeenCalledWith({
+      title: 'collections.save.hookFailedToast',
+      description: 'collections.save.hookFailedDescription',
+      data: { intent: 'warning', iconType: 'warning', icon: true, close: true },
+    })
+    expect(mocks.navigate).toHaveBeenCalledWith({
+      to: '/admin/collections/$collection/$id',
+      params: { collection: 'languages', id: testCase.expectedId },
+      search: testCase.expectedSearch,
+    })
+  })
+})

package/src/admin-shell/singletons/history.test.tsx

@@ -21,6 +21,7 @@ const mocks = vi.hoisted(() => ({
   findSingletonByVersion: vi.fn(async () => ({})),
   pagerProps: [] as Array<{ componentName: string; page: number; count: number }>,
   diffModalProps: [] as Array<Record<string, unknown>>,
+  toast: vi.fn(),
   location: {
     pathname: '/admin/singletons/site-settings/history',
     search: {} as Record<string, unknown>,
@@ -103,6 +104,7 @@ vi.mock('@byline/ui/react', () => {
     Section: Div,
     Select: () => <select aria-label="page size" />,
     Table,
+    useToastManager: () => ({ add: mocks.toast }),
   }
 })
 
@@ -404,4 +406,45 @@ describe('singleton version history', () => {
     })
     dispose()
   })
+
+  it('closes and refreshes after a restore whose afterSave hook failed post-commit', async () => {
+    mocks.restoreSingleton.mockResolvedValueOnce({
+      status: 'committed-hook-failed',
+      documentId: 'document-settings',
+      documentVersionId: 'version-restored',
+      sideEffectFailure: { phase: 'afterSave', code: 'ERR_UNHANDLED' },
+    })
+    render(
+      <SingletonHistoryView
+        singletonDefinition={singletonDefinition}
+        data={data}
+        currentDocument={currentDocument}
+        contentLocales={[]}
+        defaultContentLocale="en"
+        workflowStatuses={[]}
+      />
+    )
+
+    const restore = [...container.querySelectorAll('button')].find(
+      (button) => button.textContent === 'Restore'
+    )
+    await act(async () => restore?.click())
+    const confirm = [...container.querySelectorAll('button')].find(
+      (button) => button.textContent === 'Restore as Published'
+    )
+    await act(async () => confirm?.click())
+
+    expect(mocks.toast).toHaveBeenCalledWith({
+      title: 'collections.save.hookFailedToast',
+      description: 'collections.save.hookFailedDescription',
+      data: { intent: 'warning', iconType: 'warning', icon: true, close: true },
+    })
+    expect(mocks.invalidate).toHaveBeenCalledOnce()
+    expect(mocks.navigate).toHaveBeenLastCalledWith({
+      to: '/admin/singletons/$singleton',
+      params: { singleton: 'site-settings' },
+      search: {},
+    })
+    dispose()
+  })
 })

package/src/admin-shell/singletons/view.test.tsx

@@ -54,6 +54,14 @@ vi.mock('../../server-fns/singletons/index.js', () => ({
   copySingletonToLocale: mocks.copyToLocale,
 }))
 
+vi.mock('../../server-fns/collections/index.js', () => ({
+  hasCommittedDocumentHookFailure: (result: unknown) =>
+    typeof result === 'object' &&
+    result != null &&
+    'status' in result &&
+    result.status === 'committed-hook-failed',
+}))
+
 vi.mock('../../server-fns/preview/index.js', () => ({
   enablePreviewModeFn: vi.fn(async () => {}),
 }))
@@ -370,6 +378,25 @@ describe('SingletonView', () => {
     expect(container.textContent).toContain('Cancel')
   })
 
+  it('treats a committed afterSave failure as saved, warns, and reloads canonical state', async () => {
+    mocks.update.mockResolvedValueOnce({
+      status: 'committed-hook-failed',
+      documentId: 'doc-settings',
+      documentVersionId: 'version-next',
+      sideEffectFailure: { phase: 'afterSave', code: 'ERR_UNHANDLED' },
+    })
+    render(loadedDocument)
+    typeIntoTitle('Committed change')
+    await submit()
+
+    expect(latestToastDescription()).toContain(
+      'Your changes were saved, but a post-save update failed'
+    )
+    expect(mocks.invalidate).toHaveBeenCalledOnce()
+    expect(mocks.guardStates.at(-1)).toBe(false)
+    expect(container.textContent).toContain('Close')
+  })
+
   it('re-runs the loader and remounts before unlocking saved-document uploads', async () => {
     const loader = vi
       .fn<() => Promise<typeof loadedDocument | null>>()

package/src/admin-shell/singletons/view.tsx

@@ -23,6 +23,10 @@ import { useTranslation } from '@byline/i18n/react'
 import { Container, Section, useToastManager } from '@byline/ui/react'
 
 import { getAdminRoutePath } from '../../routes/admin-path.js'
+import {
+  hasCommittedDocumentHookFailure,
+  type SerializedDocumentPublishSchedule,
+} from '../../server-fns/collections/index.js'
 import {
   cancelSingletonScheduledPublish,
   changeSingletonStatus,
@@ -35,7 +39,6 @@ import {
 import { useNavigate } from '../chrome/loose-router.js'
 import { useTanStackNavigationGuard } from '../collections/tanstack-navigation-guard.js'
 import { SingletonViewMenu } from './view-menu.js'
-import type { SerializedDocumentPublishSchedule } from '../../server-fns/collections/index.js'
 import type { ContentLocaleOption } from '../collections/view-menu.js'
 
 type SingletonDocument = Record<string, any> & {
@@ -119,9 +122,17 @@ export function SingletonView({
     )
   }
 
+  const notifyCommittedHookFailure = () => {
+    toast(
+      t('collections.save.hookFailedToast'),
+      t('collections.save.hookFailedDescription'),
+      'warning'
+    )
+  }
+
   const handleSubmit = async ({ data }: { data: Record<string, any> }) => {
     try {
-      await updateSingleton({
+      const result = await updateSingleton({
         data: {
           singleton: path,
           data,
@@ -130,11 +141,15 @@ export function SingletonView({
         },
       })
       if (document != null) notifyScheduleSuspended()
-      toast(
-        t('singletons.edit.updateTitle', { label }),
-        t('singletons.edit.updatedDescription', { label: label.toLowerCase() }),
-        'success'
-      )
+      if (hasCommittedDocumentHookFailure(result)) {
+        notifyCommittedHookFailure()
+      } else {
+        toast(
+          t('singletons.edit.updateTitle', { label }),
+          t('singletons.edit.updatedDescription', { label: label.toLowerCase() }),
+          'success'
+        )
+      }
       await reload()
     } catch (err) {
       const code = errorCode(err)
@@ -199,7 +214,7 @@ export function SingletonView({
     overwrite: boolean
   }) => {
     try {
-      await copySingletonToLocale({
+      const result = await copySingletonToLocale({
         data: {
           singleton: path,
           sourceLocale: locale ?? defaultContentLocale,
@@ -212,14 +227,18 @@ export function SingletonView({
         contentLocales.find((entry) => entry.code === sourceLocale)?.label ?? sourceLocale
       const targetLabel =
         contentLocales.find((entry) => entry.code === targetLocale)?.label ?? targetLocale
-      toast(
-        t('collections.edit.copyToLocaleTitle', { label }),
-        t('collections.edit.copiedSuccessMessage', {
-          source: sourceLabel,
-          target: targetLabel,
-        }),
-        'success'
-      )
+      if (hasCommittedDocumentHookFailure(result)) {
+        notifyCommittedHookFailure()
+      } else {
+        toast(
+          t('collections.edit.copyToLocaleTitle', { label }),
+          t('collections.edit.copiedSuccessMessage', {
+            source: sourceLabel,
+            target: targetLabel,
+          }),
+          'success'
+        )
+      }
       notifyScheduleSuspended()
       navigate({
         to: getAdminRoutePath('singletons', '$singleton'),

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

@@ -14,6 +14,10 @@ import type { CopyToLocaleResult, DocumentLifecycleContext } from '@byline/core/
 import { copyToLocale } from '@byline/core/services'
 
 import { ensureCollection } from '../../integrations/api-utils.js'
+import {
+  type CollectionDocumentCommittedHookFailureResponse,
+  toCommittedDocumentHookFailureResponse,
+} from './save-outcome.js'
 
 // ---------------------------------------------------------------------------
 // Copy document content from one locale into another
@@ -38,34 +42,44 @@ export const copyDocumentToLocale = createServerFn({ method: 'POST' })
       overwrite: boolean
     }) => input
   )
-  .handler(async ({ data: input }): Promise<CopyToLocaleResult> => {
-    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)
-    }
+  .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)
+      }
 
-    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(),
+      }
 
-    return copyToLocale(ctx, {
-      documentId: id,
-      sourceLocale,
-      targetLocale,
-      overwrite,
-    })
-  })
+      try {
+        return await copyToLocale(ctx, {
+          documentId: id,
+          sourceLocale,
+          targetLocale,
+          overwrite,
+        })
+      } catch (error) {
+        const committedFailure = toCommittedDocumentHookFailureResponse(error)
+        if (committedFailure != null) return committedFailure
+        throw error
+      }
+    }
+  )