@things-factory/worklist 10.1.203 → 10.1.206

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "10.1.203",
+  "version": "10.1.206",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "exports": {
@@ -54,15 +54,15 @@
     "@operato/moment-timezone-es": "^10.0.0",
     "@operato/p13n": "^10.29.43",
     "@operato/popup": "^10.29.43",
-    "@things-factory/attachment-base": "^10.1.203",
-    "@things-factory/auth-base": "^10.1.203",
-    "@things-factory/board-service": "^10.1.203",
-    "@things-factory/context-ui": "^10.1.188",
-    "@things-factory/i18n-base": "^10.1.203",
-    "@things-factory/organization": "^10.1.203",
-    "@things-factory/personalization": "^10.1.203",
-    "@things-factory/scheduler-client": "^10.1.203",
-    "@things-factory/shell": "^10.1.188"
+    "@things-factory/attachment-base": "^10.1.206",
+    "@things-factory/auth-base": "^10.1.206",
+    "@things-factory/board-service": "^10.1.206",
+    "@things-factory/context-ui": "^10.1.206",
+    "@things-factory/i18n-base": "^10.1.206",
+    "@things-factory/organization": "^10.1.206",
+    "@things-factory/personalization": "^10.1.206",
+    "@things-factory/scheduler-client": "^10.1.206",
+    "@things-factory/shell": "^10.1.206"
   },
-  "gitHead": "031aaae3b75b2975e6bce007b3ad7d8d74fe60c8"
+  "gitHead": "18588a058a4a6cb21c379b2da5517e077c6442ba"
 }

package/tests/pick-race.pg.test.ts

@@ -7,7 +7,8 @@ import { join } from 'path'
  * between. Runs only when WORKLIST_PG_URL names a postgres server (see discard-versus-issue.pg.test.ts).
  *
  * A case waiting for one person must end with one thread, whoever wins; and one person pressing twice
- * must not hold it twice.
+ * must not hold it twice. A case in a pool waits with one unassigned thread: whoever takes it, by pick or
+ * by claim, takes that thread, and nothing is left waiting once the case has its people.
  */
 
 const url = process.env.WORKLIST_PG_URL
@@ -23,6 +24,7 @@ maybe('picking at once, on postgres', () => {
   const { ActivityThread } = require(join(DIST, 'service', 'activity-thread', 'activity-thread.js'))
   const { ActivityApproval } = require(join(DIST, 'service', 'activity-approval', 'activity-approval.js'))
   const { pick } = require(join(DIST, 'controllers', 'activity-instance', 'pick.js'))
+  const { start } = require(join(DIST, 'controllers', 'activity-thread', 'start.js'))
   const { Domain } = require('@things-factory/shell')
   const { Role, User } = require('@things-factory/auth-base')
 
@@ -125,4 +127,80 @@ maybe('picking at once, on postgres', () => {
       expect(await threadsOf(instance)).toBe(2)
     }
   }, 120000)
+
+  /** The shape issue() and a pool assign make: the pool, threadsMin, one unassigned thread. */
+  const aPoolCase = async (name: string, threadsMin: number) => {
+    const instance = await db.getRepository(ActivityInstance).save({
+      domain,
+      name,
+      state: 'issued',
+      activity,
+      assigneeRoles: [role],
+      threadsMin,
+      threadsMax: threadsMin
+    })
+    const waiting = await db.getRepository(ActivityThread).save({ domain, activityInstance: instance, state: 'unassigned' })
+    return { instance, waiting }
+  }
+
+  const statesOf = async (instance: any) =>
+    (await db.getRepository(ActivityThread).find({ where: { activityInstance: { id: instance.id } } }))
+      .map((thread: any) => [thread.state, thread.assigneeId || null])
+      .sort((a: any, b: any) => String(a).localeCompare(String(b)))
+
+  it('two members picking a pool case that waits for one: one holds the waiting thread, nothing is left waiting', async () => {
+    for (let round = 0; round < 20; round++) {
+      const { instance, waiting } = await aPoolCase(`pool${round}`, 1)
+
+      const results = await Promise.allSettled([
+        db.transaction((tx: any) => pick(instance.id, as(first)(tx))),
+        db.transaction((tx: any) => pick(instance.id, as(second)(tx)))
+      ])
+
+      const won = results.findIndex(one => one.status === 'fulfilled')
+      expect(results.filter(one => one.status === 'fulfilled').length).toBe(1)
+      expect((results[won] as any).value.id).toBe(waiting.id)
+      expect(await statesOf(instance)).toEqual([['assigned', [first, second][won].id]])
+    }
+  }, 120000)
+
+  it('a pick and a claim of the waiting thread at once: exactly one wins, and it holds the one thread', async () => {
+    const endings: string[] = []
+
+    for (let round = 0; round < 20; round++) {
+      const { instance, waiting } = await aPoolCase(`claim${round}`, 1)
+
+      const [picked, claimed] = await Promise.allSettled([
+        db.transaction((tx: any) => pick(instance.id, as(first)(tx))),
+        db.transaction((tx: any) => start(waiting.id, {}, '', as(second)(tx)))
+      ])
+      endings.push(`pick ${picked.status} · claim ${claimed.status}`)
+
+      expect([picked.status, claimed.status].filter(status => status === 'fulfilled').length).toBe(1)
+      expect(await statesOf(instance)).toEqual(
+        picked.status === 'fulfilled' ? [['assigned', first.id]] : [['started', second.id]]
+      )
+    }
+
+    console.log('endings', [...new Set(endings)].join(' · '))
+  }, 120000)
+
+  it('two members picking a pool case that waits for two: both hold a thread, nothing is left waiting', async () => {
+    for (let round = 0; round < 10; round++) {
+      const { instance } = await aPoolCase(`pool-two${round}`, 2)
+
+      const results = await Promise.allSettled([
+        db.transaction((tx: any) => pick(instance.id, as(first)(tx))),
+        db.transaction((tx: any) => pick(instance.id, as(second)(tx)))
+      ])
+
+      expect(results.map(one => one.status)).toEqual(['fulfilled', 'fulfilled'])
+      expect(await statesOf(instance)).toEqual(
+        [
+          ['assigned', first.id],
+          ['assigned', second.id]
+        ].sort((a: any, b: any) => String(a).localeCompare(String(b)))
+      )
+    }
+  }, 120000)
 })

package/tests/pool-pick-waiting-thread.test.ts

@@ -0,0 +1,254 @@
+import { join } from 'path'
+
+/**
+ * A pool's waiting thread, taken by pick or by claim (2026-10-20).
+ *
+ * A case in a role's pool carries one unassigned thread, and the to-do list of every pool holder reads that
+ * thread (my-open-threads.ts). Pick made a new assigned thread beside it and left it there, so a case one
+ * member had taken stayed on everyone else's list. The rule now, whichever door is used:
+ *
+ *   - the taker gets the waiting thread itself;
+ *   - while the case still waits for more people (fewer valid threads than threadsMin), one waiting thread is
+ *     left for the rest of the pool, and none once it has enough;
+ *   - one person holds one thread of a case - a second take is refused by name, and the waiting thread is off
+ *     the list of whoever already holds one.
+ *
+ * Real entities on sqlite, as assign-role-pool.test.ts.
+ */
+
+/* Nobody here manages activity instances - the role is the only way in. */
+jest.mock('@things-factory/auth-base', () => {
+  const actual = jest.requireActual('@things-factory/auth-base')
+  return { ...actual, checkPermission: async () => false }
+})
+
+const { createSqliteTestDataSource } = require(join(__dirname, '..', '..', 'ops-master', 'test', 'support', 'database.cjs'))
+const DIST = join(__dirname, '..', 'dist-server')
+const { Activity } = require(join(DIST, 'service', 'activity', 'activity.js'))
+const { ActivityInstance } = require(join(DIST, 'service', 'activity-instance', 'activity-instance.js'))
+const { ActivityThread } = require(join(DIST, 'service', 'activity-thread', 'activity-thread.js'))
+const { ActivityApproval } = require(join(DIST, 'service', 'activity-approval', 'activity-approval.js'))
+const { myOpenThreadsWhere } = require(join(DIST, 'service', 'activity-thread', 'my-open-threads.js'))
+const { assign } = require(join(DIST, 'controllers', 'activity-instance', 'assign.js'))
+const { issue } = require(join(DIST, 'controllers', 'activity-instance', 'issue.js'))
+const { pick } = require(join(DIST, 'controllers', 'activity-instance', 'pick.js'))
+const { start } = require(join(DIST, 'controllers', 'activity-thread', 'start.js'))
+const { Domain } = require('@things-factory/shell')
+const { Role, User } = require('@things-factory/auth-base')
+
+let db: any
+let here: any
+let manager: any
+let first: any
+let second: any
+let third: any
+let outsider: any
+let pool: any
+let elsewhere: any
+let activity: any
+
+beforeAll(async () => {
+  db = createSqliteTestDataSource([Activity, ActivityInstance, ActivityThread, ActivityApproval])
+  await db.initialize()
+
+  here = await db.getRepository(Domain).save({ name: 'here', subdomain: 'here' })
+
+  const person = (name: string) =>
+    db.getRepository(User).save({ name, email: `${name}@example.com`, password: 'x', status: 'activated', userType: 'user', domains: [here] })
+
+  manager = await person('manager')
+  first = await person('first')
+  second = await person('second')
+  third = await person('third')
+  outsider = await person('outsider')
+
+  pool = await db.getRepository(Role).save({ domain: here, name: 'finance', users: [first, second, third] })
+  elsewhere = await db.getRepository(Role).save({ domain: here, name: 'support', users: [outsider] })
+
+  activity = await db.getRepository(Activity).save({ domain: here, name: 'tax-invoice', activityType: 'standard', startingType: 'issue' })
+})
+
+afterAll(async () => db?.destroy())
+
+const as = (user: any, tx: any) => ({ state: { domain: here, user, tx }, t: (key: string) => key }) as any
+
+const pickAs = (user: any, instance: any) => db.transaction((tx: any) => pick(instance.id, as(user, tx)))
+const claimAs = (user: any, thread: any) => db.transaction((tx: any) => start(thread.id, {}, '', as(user, tx)))
+
+const reread = (instance: any) => db.getRepository(ActivityInstance).findOneBy({ id: instance.id })
+
+/** [state, holder] of every thread of the case, holders by name, in a fixed order. */
+const threadsOf = async (instance: any) => {
+  const threads = await db.getRepository(ActivityThread).find({ where: { activityInstance: { id: instance.id } } })
+  const names = new Map([first, second, third, outsider, manager].map((user: any) => [user.id, user.name]))
+  return threads.map((thread: any) => [thread.state, names.get(thread.assigneeId) || null]).sort((a: any, b: any) => String(a).localeCompare(String(b)))
+}
+
+const waitingOf = async (instance: any) =>
+  (await db.getRepository(ActivityThread).find({ where: { activityInstance: { id: instance.id }, state: 'unassigned' } }))[0]
+
+/** How many times the case is on this person's to-do list - the list's own condition (my-open-threads.ts). */
+const onTheListOf = (user: any, roles: any[], instance: any) =>
+  db
+    .getRepository(ActivityThread)
+    .createQueryBuilder('at')
+    .innerJoin('at.activityInstance', 'ai')
+    .where(myOpenThreadsWhere({ userId: user.id, roles: roles.map(role => role.id) }))
+    .andWhere('ai.id = :id', { id: instance.id })
+    .getCount()
+
+/** The case as each pool member and the outsider see it on their lists. */
+const lists = async (instance: any) => ({
+  first: await onTheListOf(first, [pool], instance),
+  second: await onTheListOf(second, [pool], instance),
+  third: await onTheListOf(third, [pool], instance),
+  outsider: await onTheListOf(outsider, [elsewhere], instance)
+})
+
+const issued = (threadsMin: number) =>
+  db.transaction((tx: any) => issue({ activityId: activity.id, assignees: [], assigneeRoles: [pool], threadsMin }, as(manager, tx)))
+
+const assigned = async () => {
+  const instance = await db.getRepository(ActivityInstance).save({ domain: here, name: 'case', state: 'issued', activity })
+  await db.transaction((tx: any) => assign({ id: instance.id, assigneeRoles: [pool.id] }, as(manager, tx)))
+  return instance
+}
+
+describe('a pool waiting for one person', () => {
+  it.each([
+    ['issued with an assignee role', () => issued(1)],
+    ['put in a pool by assign', assigned]
+  ])('%s, picked by a member: the waiting thread is theirs, and the rest of the pool no longer sees the case', async (_, made) => {
+    const instance = await made()
+    const [waiting] = await threadsOf(instance)
+    expect(waiting).toEqual(['unassigned', null])
+
+    await pickAs(first, instance)
+
+    expect(await threadsOf(instance)).toEqual([['assigned', 'first']])
+    expect((await reread(instance)).state).toBe('assigned')
+    expect(await lists(instance)).toEqual({ first: 1, second: 0, third: 0, outsider: 0 })
+  })
+
+  it('pick returns the waiting thread itself, now held', async () => {
+    const instance = await issued(1)
+    const waiting = await waitingOf(instance)
+
+    const picked = await pickAs(first, instance)
+
+    expect(picked.id).toBe(waiting.id)
+    expect([picked.state, picked.assigneeId]).toEqual(['assigned', first.id])
+  })
+
+  it('a second member picking after it is refused by name and the case is left as it was', async () => {
+    const instance = await issued(1)
+    await pickAs(first, instance)
+
+    await expect(pickAs(second, instance)).rejects.toThrow('error.activity-instance should not be assigned')
+    expect(await threadsOf(instance)).toEqual([['assigned', 'first']])
+  })
+
+  it('claimed by a member: as before, one thread, theirs, off the rest of the pool', async () => {
+    const instance = await issued(1)
+
+    await claimAs(first, await waitingOf(instance))
+
+    expect(await threadsOf(instance)).toEqual([['started', 'first']])
+    expect(await lists(instance)).toEqual({ first: 1, second: 0, third: 0, outsider: 0 })
+  })
+
+  it('a case with no waiting thread is picked as before - a new thread for the picker', async () => {
+    const instance = await db.getRepository(ActivityInstance).save({
+      domain: here,
+      name: 'bare',
+      state: 'issued',
+      activity,
+      assigneeRoles: [pool],
+      threadsMin: 1
+    })
+
+    await pickAs(first, instance)
+
+    expect(await threadsOf(instance)).toEqual([['assigned', 'first']])
+  })
+})
+
+describe('a pool waiting for two people (threadsMin 2)', () => {
+  it('the first pick takes the waiting thread and leaves one for the rest; the second fills it and none is left', async () => {
+    const instance = await issued(2)
+    expect(await threadsOf(instance)).toEqual([['unassigned', null]])
+
+    await pickAs(first, instance)
+
+    expect(await threadsOf(instance)).toEqual([
+      ['assigned', 'first'],
+      ['unassigned', null]
+    ])
+    expect((await reread(instance)).state).toBe('unassigned')
+    /* first sees their own thread once - not the pool's waiting thread beside it. */
+    expect(await lists(instance)).toEqual({ first: 1, second: 1, third: 1, outsider: 0 })
+
+    await pickAs(second, instance)
+
+    expect(await threadsOf(instance)).toEqual([
+      ['assigned', 'first'],
+      ['assigned', 'second']
+    ])
+    expect((await reread(instance)).state).toBe('assigned')
+    expect(await lists(instance)).toEqual({ first: 1, second: 1, third: 0, outsider: 0 })
+  })
+
+  it('the same by claiming the waiting thread each time', async () => {
+    const instance = await issued(2)
+
+    await claimAs(first, await waitingOf(instance))
+
+    expect(await threadsOf(instance)).toEqual([
+      ['started', 'first'],
+      ['unassigned', null]
+    ])
+    expect(await lists(instance)).toEqual({ first: 1, second: 1, third: 1, outsider: 0 })
+
+    await claimAs(second, await waitingOf(instance))
+
+    expect(await threadsOf(instance)).toEqual([
+      ['started', 'first'],
+      ['started', 'second']
+    ])
+    expect(await lists(instance)).toEqual({ first: 1, second: 1, third: 0, outsider: 0 })
+  })
+
+  it('one picks, the next claims: two holders, nothing left waiting', async () => {
+    const instance = await issued(2)
+
+    await pickAs(first, instance)
+    await claimAs(second, await waitingOf(instance))
+
+    expect(await threadsOf(instance)).toEqual([
+      ['assigned', 'first'],
+      ['started', 'second']
+    ])
+  })
+
+  it('someone who holds a thread already is refused by name a second one, by pick or by claim', async () => {
+    const instance = await issued(2)
+    await pickAs(first, instance)
+
+    await expect(pickAs(first, instance)).rejects.toThrow('error.activity-instance already yours')
+    await expect(claimAs(first, await waitingOf(instance))).rejects.toThrow('error.activity-instance already yours')
+
+    expect(await threadsOf(instance)).toEqual([
+      ['assigned', 'first'],
+      ['unassigned', null]
+    ])
+  })
+
+  it('someone outside the pool is refused the waiting thread, and it stays waiting', async () => {
+    const instance = await issued(2)
+
+    await expect(pickAs(outsider, instance)).rejects.toThrow('error.activity-instance is addressed to another role')
+    await expect(claimAs(outsider, await waitingOf(instance))).rejects.toThrow('error.not authorized to handle this task')
+
+    expect(await threadsOf(instance)).toEqual([['unassigned', null]])
+  })
+})

package/translations/en.json

@@ -34,6 +34,7 @@
   "error.activity-approval taken by someone else": "someone else handled this approval first. reload the list to see where it stands.",
   "error.activity-instance belongs to someone else": "{id} is someone else's draft. Only the person who wrote it, or someone who manages activity instances, may edit or issue it.",
   "error.activity-instance is addressed to another role": "{id} is assigned to another role. only someone with that role can pick it.",
+  "error.activity-instance already yours": "you already hold this task ({id}).",
   "error.activity-instance is already issued": "this task ({id}) has already been issued with the {state} status.",
   "error.activity-instance is already terminated": "this task ({id}) has already been terminated with the {state} status.",
   "error.activity-instance approval line is set": "this task already has its approval line; it is set on the task's detail screen.",

package/translations/es.json

@@ -34,6 +34,7 @@
   "error.activity-approval taken by someone else": "otra persona resolvió esta aprobación antes. vuelva a cargar la lista para ver su estado.",
   "error.activity-instance belongs to someone else": "{id} es un borrador de otra persona. Solo quien lo redactó, o quien gestiona las instancias de actividad, puede editarlo o emitirlo.",
   "error.activity-instance is addressed to another role": "{id} está asignado a otro rol. solo alguien con ese rol puede seleccionarlo.",
+  "error.activity-instance already yours": "ya tiene esta tarea ({id}).",
   "error.activity-instance is already issued": "esta tarea ({id}) ya se emitió con el estado {state}.",
   "error.activity-instance is already terminated": "esta tarea ({id}) ya finalizó con el estado {state}.",
   "error.activity-instance approval line is set": "esta tarea ya tiene su línea de aprobación; se configura en la pantalla de detalle de la tarea.",

package/translations/ja.json

@@ -34,6 +34,7 @@
   "error.activity-approval taken by someone else": "他の方が先に処理しました。一覧を再読み込みしてください。",
   "error.activity-instance belongs to someone else": "{id} is someone else's draft. Only the person who wrote it, or someone who manages activity instances, may edit or issue it.",
   "error.activity-instance is addressed to another role": "{id} は別の役割に割り当てられた業務です。その役割を持つ人だけが選択できます。",
+  "error.activity-instance already yours": "この業務({id})はすでに担当しています。",
   "error.activity-instance is already issued": "このタスク({id})はすでに{state}状態で発行されています。",
   "error.activity-instance is already terminated": "このタスク({id})はすでに{state}状態で終了しています。",
   "error.activity-instance approval line is set": "この業務は決裁ラインが決まっています。決裁ラインは業務詳細で変更します。",

package/translations/ko.json

@@ -34,6 +34,7 @@
   "error.activity-approval taken by someone else": "다른 분이 먼저 처리했습니다. 목록을 새로 읽어 주십시오.",
   "error.activity-instance belongs to someone else": "{id}은(는) 다른 사용자가 작성한 초안입니다. 작성자 또는 업무 관리자만 수정하고 제출할 수 있습니다.",
   "error.activity-instance is addressed to another role": "{id} 는 다른 역할에 할당된 업무입니다. 그 역할을 가진 사람만 선택할 수 있습니다.",
+  "error.activity-instance already yours": "이미 맡은 업무입니다({id}).",
   "error.activity-instance is already issued": "이 작업({id})은 이미 {state} 상태로 제기되었습니다.",
   "error.activity-instance is already terminated": "이 작업({id})는 이미 {state} 상태로 종료되었습니다.",
   "error.activity-instance approval line is set": "이 업무에는 결재선이 지정되어 있습니다. 업무 상세 화면에서 결재선을 변경해 주세요.",

package/translations/ms.json

@@ -34,6 +34,7 @@
   "error.activity-approval taken by someone else": "orang lain telah menguruskannya dahulu. sila muat semula senarai.",
   "error.activity-instance belongs to someone else": "{id} is someone else's draft. Only the person who wrote it, or someone who manages activity instances, may edit or issue it.",
   "error.activity-instance is addressed to another role": "{id} ditugaskan kepada peranan lain. hanya orang yang memegang peranan itu boleh memilihnya.",
+  "error.activity-instance already yours": "anda sudah memegang tugas ini ({id}).",
   "error.activity-instance is already issued": "Tugas ini ({id}) telah dikeluarkan dengan status {state}.",
   "error.activity-instance is already terminated": "Tugas ini ({id}) telah tamat dengan status {state}.",
   "error.activity-instance approval line is set": "tugas ini sudah mempunyai laluan kelulusan; ia ditetapkan pada skrin butiran tugas.",

package/translations/zh.json

@@ -34,6 +34,7 @@
   "error.activity-approval taken by someone else": "他人已先行处理，请重新加载列表。",
   "error.activity-instance belongs to someone else": "{id} is someone else's draft. Only the person who wrote it, or someone who manages activity instances, may edit or issue it.",
   "error.activity-instance is addressed to another role": "{id} 已分配给其他角色。只有拥有该角色的人员才能选择。",
+  "error.activity-instance already yours": "您已负责此任务（{id}）。",
   "error.activity-instance is already issued": "此任务({id})已被以{state}状态提出。",
   "error.activity-instance is already terminated": "此任务({id})已以{state}状态终止。",
   "error.activity-instance approval line is set": "此业务已设定审批线，请在业务详情中修改。",