@prenta/admin 2.7.0 → 2.8.0

package/src/__tests__/lib/job-view.test.ts

@@ -2,17 +2,22 @@ import { describe, expect, it } from 'vitest'
 import type { Job, JobWorkerStatus } from '@prenta/core'
 
 import {
+  canActOnJobs,
+  canRetryJob,
   countJobs,
   formatCreated,
   formatDuration,
   formatNextRun,
   formatSince,
   hasReviewAction,
+  jobActions,
   matchJob,
+  retryPoint,
   scheduleLabel,
   toJobRows,
   view,
   type JobRow,
+  type JobViewer,
 } from '../../lib/job-view.js'
 
 function row(overrides: Partial<JobRow>): JobRow {
@@ -35,8 +40,10 @@ function row(overrides: Partial<JobRow>): JobRow {
     pending: 0,
     items: false,
     review: null,
+    adminRetry: false,
     took: null,
     by: 'Brandon West',
+    byId: null,
     created: 'now',
     ...overrides,
   }
@@ -386,11 +393,125 @@ describe('toJobRows()', () => {
       review: null,
       created: 'Today 12:00',
     })
-    expect(cron).toMatchObject({ cancelledBy: 'Dana Cole', by: 'Dana Cole' })
-    expect(nightly).toMatchObject({ by: 'Nightly cron', created: 'Yesterday 12:00' })
+    expect(cron).toMatchObject({ cancelledBy: 'Dana Cole', by: 'Dana Cole', byId: 'u2' })
+    expect(nightly).toMatchObject({ by: 'Nightly cron', byId: null, created: 'Yesterday 12:00' })
     expect(review).toMatchObject({ pending: 2, items: true })
     expect(review && view(review).l).toBe('Needs review')
   })
+
+  it('counts a batch that hasn’t started by its frozen documents', () => {
+    const fresh = (type: string, ids: string[]) =>
+      apiJob({
+        type,
+        progress: { done: 0, total: 0, unit: 'documents', cursor: null, completed: 0 },
+        payload: { ...(apiJob({}).payload as object), documentIds: ids } as Job['payload'],
+      })
+    const [batch, scan, started] = toJobRows(
+      [
+        fresh('batch-ai', ['a', 'b', 'c']),
+        fresh('seo-scan', ['a']),
+        apiJob({ progress: { done: 2, total: 5, unit: 'documents', cursor: '2', completed: 2 } }),
+      ],
+      NOW,
+      null,
+    )
+    expect([batch?.total, scan?.total, started?.total]).toEqual([3, 0, 5])
+  })
+
+  it('makes only a stored "Apply automatically" admin-only to retry, as cms-core does', () => {
+    const batch = (review: 'review' | 'auto', origin?: 'ai-batch') =>
+      apiJob({
+        payload: {
+          ...(apiJob({}).payload as object),
+          review,
+          ...(origin ? { origin } : {}),
+        } as Job['payload'],
+      })
+    const [review, auto, bulk] = toJobRows(
+      [batch('review'), batch('auto'), batch('auto', 'ai-batch')],
+      NOW,
+      null,
+    )
+    expect([review?.adminRetry, auto?.adminRetry, bulk?.adminRetry]).toEqual([false, true, false])
+    // The bulk action still reads as applying directly, for the cancel copy.
+    expect(bulk?.review).toBe('auto')
+  })
+})
+
+const as = (role: string | null, userId: string | null = 'u1'): JobViewer => ({ role, userId })
+
+describe('job actions (P-19)', () => {
+  it('lets the roles core calls writers run and cancel, and nobody else', () => {
+    for (const role of ['OWNER', 'ADMIN', 'EDITOR', 'AUTHOR', 'editor'])
+      expect(canActOnJobs(as(role))).toBe(true)
+    for (const role of ['VIEWER', 'CLIENT', 'SOMETHING_NEW', null])
+      expect(canActOnJobs(as(role))).toBe(false)
+  })
+
+  it('retries a batch for an admin, or for the editor who queued it unless it was "Apply automatically"', () => {
+    const mine = row({ review: 'review', byId: 'u1' })
+    const theirs = row({ review: 'review', byId: 'u2' })
+    const auto = row({ review: 'auto', adminRetry: true, byId: 'u1' })
+    // A list's bulk action (`/ai/batch`): it applies directly, but any editor may queue it.
+    const legacy = row({ review: 'auto', adminRetry: false, byId: 'u1' })
+    const scan = row({ type: 'seo-scan', review: null, byId: null })
+    expect([mine, theirs, auto, legacy, scan].map((j) => canRetryJob(j, as('ADMIN')))).toEqual([
+      true,
+      true,
+      true,
+      true,
+      true,
+    ])
+    expect([mine, theirs, auto, legacy, scan].map((j) => canRetryJob(j, as('EDITOR')))).toEqual([
+      true,
+      false,
+      false,
+      true,
+      true,
+    ])
+    expect(canRetryJob(mine, as('VIEWER'))).toBe(false)
+    expect(canRetryJob(row({ byId: null }), as('EDITOR', null))).toBe(false)
+  })
+
+  it('offers the drawer footer’s actions per state (jobs-drawer.jsx `.jd-f`)', () => {
+    const admin = as('ADMIN')
+    const actions = (overrides: Partial<JobRow>) => jobActions(row(overrides), admin)
+    expect(actions({ state: 'running' })).toEqual({ cancel: true, retry: false, retryNow: false })
+    expect(actions({ state: 'running', cancelling: true })).toEqual({
+      cancel: false,
+      retry: false,
+      retryNow: false,
+    })
+    expect(actions({ state: 'queued', error: 'Boom' })).toEqual({
+      cancel: true,
+      retry: false,
+      retryNow: true,
+    })
+    // A retry clears a cancel, so a cancelling job doesn't offer it.
+    expect(actions({ state: 'queued', error: 'Boom', cancelling: true }).retryNow).toBe(false)
+    // A stale lock: the server still holds it as running and would refuse a retry.
+    expect(
+      actions({ state: 'queued', status: 'running', error: 'Worker stopped mid-slice' }),
+    ).toEqual({ cancel: true, retry: false, retryNow: false })
+    expect(actions({ state: 'dead', error: 'Boom' })).toEqual({
+      cancel: false,
+      retry: true,
+      retryNow: false,
+    })
+    for (const state of ['succeeded', 'cancelled'] as const)
+      expect(actions({ state })).toEqual({ cancel: false, retry: false, retryNow: false })
+    expect(jobActions(row({ state: 'dead' }), as('VIEWER'))).toEqual({
+      cancel: false,
+      retry: false,
+      retryNow: false,
+    })
+  })
+
+  it('says where a retry picks up, in pages for an SEO scan', () => {
+    expect(retryPoint({ type: 'batch-ai', done: 7 })).toBe('document 8')
+    expect(retryPoint({ type: 'content-health', done: 0 })).toBe('document 1')
+    expect(retryPoint({ type: 'seo-scan', done: 100 })).toBe('page 101')
+  })
 })
 
 describe('formatting', () => {

package/src/__tests__/lib/jobs-service.test.ts

@@ -3,17 +3,86 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 /*
  * The drawer's calls in the Jobs service: the review page query, the
  * decision envelope's `documentStatus` and `notice`, and reading why a
- * decision was refused.
+ * decision was refused. And the batch wizard's: estimate, preview, create.
  */
 
 const cmsApi = vi.hoisted(() => vi.fn())
 vi.mock('../../lib/api.js', () => ({ cmsApi, getApiBase: () => '/api/cms' }))
 
-const { decideReviewItem, listReviewItems, reviewConflict } =
-  await import('../../lib/jobs-service.js')
+const {
+  createBatchAiJob,
+  decideReviewItem,
+  estimateBatchAi,
+  listReviewItems,
+  previewBatchAi,
+  reviewConflict,
+} = await import('../../lib/jobs-service.js')
 
 beforeEach(() => cmsApi.mockReset())
 
+describe('batch AI', () => {
+  const request = {
+    operation: 'custom' as const,
+    source: 'posts',
+    statusFilter: 'all' as const,
+    review: 'review' as const,
+    onApprove: 'draft' as const,
+    instruction: 'Translate it & keep names',
+    field: 'excerpt' as const,
+    filter: { documentIds: ['a', 'b'] },
+  }
+
+  it('estimates with the request as the query, ids comma-separated', async () => {
+    const value = { count: 2, sample: [], tokens: 1800, minutes: 2, pctOfMonthlyLimit: null }
+    cmsApi.mockResolvedValue({ data: value, status: 200 })
+    expect(await estimateBatchAi(request)).toEqual({ ok: true, value })
+    const [endpoint] = cmsApi.mock.calls[0]!
+    expect(endpoint).toBe(
+      '/jobs/batch-ai/estimate?operation=custom&source=posts&statusFilter=all&field=excerpt&instruction=Translate+it+%26+keep+names&documentIds=a%2Cb',
+    )
+    cmsApi.mockClear()
+    await estimateBatchAi({
+      ...request,
+      operation: 'meta',
+      field: undefined,
+      instruction: null,
+      filter: undefined,
+    })
+    expect(cmsApi.mock.calls[0]![0]).toBe(
+      '/jobs/batch-ai/estimate?operation=meta&source=posts&statusFilter=all',
+    )
+  })
+
+  it('previews with a POST, reading the items', async () => {
+    const items = [{ documentId: 'a', title: 'A', after: 'New text.' }]
+    cmsApi.mockResolvedValue({ data: { items }, status: 200 })
+    expect(await previewBatchAi(request)).toEqual({ ok: true, value: items })
+    expect(cmsApi.mock.calls[0]![0]).toBe('/jobs/batch-ai/preview')
+    expect(cmsApi.mock.calls[0]![1]).toMatchObject({
+      method: 'POST',
+      body: JSON.stringify(request),
+    })
+  })
+
+  it('passes a spent cap on', async () => {
+    cmsApi.mockResolvedValue({ error: 'AI limit reached', status: 429 })
+    expect(await previewBatchAi(request)).toEqual({
+      ok: false,
+      error: 'AI limit reached',
+      status: 429,
+    })
+  })
+
+  it('creates with a POST and returns the job', async () => {
+    cmsApi.mockResolvedValue({ data: { id: 'job_420' }, status: 201 })
+    expect(await createBatchAiJob(request)).toEqual({ ok: true, value: { id: 'job_420' } })
+    expect(cmsApi).toHaveBeenCalledWith('/jobs/batch-ai', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    })
+  })
+})
+
 describe('listReviewItems', () => {
   it('asks for 20 at a time, from a cursor', async () => {
     cmsApi.mockResolvedValue({ data: { items: [], nextCursor: null }, status: 200 })