@owlmeans/client-planning 0.1.18-rc.9 → 0.1.18

package/tests/lifecycle-commits.spec.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'bun:test'
+import { CommitTimeout, TransitionAction, WorkcardKind } from '@owlmeans/planning'
+import { makePlanningResourceFeed } from '../src/index.js'
+import { makeSuite, protocols, STORY, tick } from './context.js'
+import { makeBarrier } from './lifecycle/context.js'
+
+describe('@owlmeans/client-planning — commit cancellation', () => {
+  test('rejects delayed status and held replies, and never retries a stale failed hold', async () => {
+    for (const mode of ['status', 'hold', 'failed-hold'] as const) {
+      let identity = 'a'
+      let active = false
+      const started = makeBarrier()
+      const reply = makeBarrier()
+      const suite = await makeSuite({ sync: false, schemas: false, scopeKey: () => identity,
+        before: async request => { if (active && request.alias === protocols.commit.get.alias && Number((request.query as Record<string, unknown>)?.wait) > 0) { void started.hold() } },
+        after: async call => {
+          if (!active || call.alias !== protocols.commit.get.alias || (mode === 'status') !== (Number(call.query.wait) === 0)) return
+          await reply.hold()
+          if (mode === 'failed-hold') throw new Error('Carrier dropped after close')
+        },
+      })
+      const project = await suite.project()
+      const receipt = await suite.planning.execute({ action: TransitionAction.Create, card: { kind: WorkcardKind.Card, type: STORY, parent: project.id!, title: 'Delayed old card' } })
+      active = true
+      const waiting = receipt.committed({ timeout: 5000 })
+      void waiting.catch(() => {})
+      if (mode !== 'status') { await started.entered; await suite.store.flush() }
+      await reply.entered
+      await suite.client.planning().close()
+      await expect(waiting).rejects.toThrow('scope-changed')
+      identity = 'b'
+      const count = suite.calls.length
+      reply.release(); started.release()
+      await tick(10)
+      expect(suite.calls.length).toBe(count)
+      expect((await suite.client.planningStores!().cards.list({}, { size: 0 })).items).toEqual([])
+      expect((await suite.client.planningStores!().commits.list({}, { size: 0 })).items).toEqual([])
+      await suite.client.planning().close()
+    }
+  })
+
+  test('a deadline also bounds an unresolved socket opener and an initial status RPC', async () => {
+    for (const socket of [true, false]) {
+      const pause = makeBarrier()
+      const suite = await makeSuite({ schemas: false, socket,
+        opening: async () => await pause.hold(),
+        after: async call => { if (!socket && call.alias === protocols.commit.get.alias) await pause.hold() },
+      })
+      const project = await suite.project()
+      const waiting = suite.planning.commits.wait((await suite.local.transitions.list({ card: project.id! })).items[0]!.id!, { timeout: 40 })
+      void waiting.catch(() => {})
+      await pause.entered
+      await expect(waiting).rejects.toBeInstanceOf(CommitTimeout)
+      await suite.client.planning().close()
+      pause.release()
+      await tick()
+      expect(suite.client.planning().commits.connected()).toBe(false)
+    }
+  })
+
+  test('a new organization works after close while a late old reply cannot enter its mirror', async () => {
+    let identity = 'organization-a'
+    const pause = makeBarrier()
+    let delay = false
+    const suite = await makeSuite({ resources: true, schemas: false, entityId: () => identity, scopeKey: () => identity,
+      after: async call => { if (delay && call.alias === protocols.commit.get.alias) await pause.hold() },
+    })
+    const project = await suite.project()
+    delay = true
+    let invalidations = 0
+    suite.client.planning().lifecycle.onInvalidate(() => { invalidations++ })
+    const old = suite.planning.commits.wait((await suite.local.transitions.list({ card: project.id! })).items[0]!.id!, { timeout: 5000 })
+    void old.catch(() => {})
+    await pause.entered
+    await suite.client.planning().close()
+    await expect(old).rejects.toThrow('scope-changed')
+    expect(invalidations).toBe(1)
+    identity = 'organization-b'
+    await suite.client.planning().loadSchemas()
+    const feed = makePlanningResourceFeed(suite.client, { teams: { size: 0 }, refresh: 0 })
+    await feed.ready
+    expect(feed.seeded).toBe(true)
+    expect(invalidations).toBe(1)
+    const fresh = await suite.planning.teams.create({ name: 'Organization B', fields: {} })
+    pause.release()
+    await tick(10)
+    expect((await suite.client.planningStores!().teams.list({}, { size: 0 })).items.map(team => team.id)).toEqual([fresh.id])
+    expect((await suite.client.planningStores!().cards.list({}, { size: 0 })).items).toEqual([])
+    expect((await suite.local.teams.list()).items).toEqual([])
+    await suite.client.planning().close()
+  })
+})

package/tests/lifecycle-definitions.spec.ts

@@ -0,0 +1,28 @@
+import { expect, test } from 'bun:test'
+import { WorkcardKind } from '@owlmeans/planning'
+import { definitionProtocols, makeSuite, STORY_FLOW, tick } from './context.js'
+import { makeBarrier } from './lifecycle/context.js'
+
+test('a stale schema write rejects without invalidating the fresh organization registry', async () => {
+  let identity = 'organization-a'
+  const pause = makeBarrier()
+  const suite = await makeSuite({ definitions: true, schemas: false, entityId: () => identity, scopeKey: () => identity,
+    after: async call => { if (call.alias === definitionProtocols.schema.define!.alias) await pause.hold() },
+  })
+  const definitions = suite.planning.definitions!
+  const writing = definitions.define({ types: [{ type: 'test:old-type', kind: WorkcardKind.Card, version: 1,
+    fields: { type: 'object' }, flows: [STORY_FLOW], specifications: [] }] })
+  void writing.catch(() => {})
+  await pause.entered
+  await suite.client.planning().close()
+  await expect(writing).rejects.toThrow('scope-changed')
+  identity = 'organization-b'
+  const fresh = await definitions.registry()
+  const reads = suite.calls.filter(call => call.alias === definitionProtocols.schema.list.alias).length
+  pause.release(); await tick(10)
+  expect(await definitions.registry()).toBe(fresh)
+  expect(suite.calls.filter(call => call.alias === definitionProtocols.schema.list.alias)).toHaveLength(reads)
+  expect(fresh.bundle().types.some(type => type.type === 'test:old-type')).toBe(false)
+  expect((await suite.local.definitions!.bundle()).types.some(type => type.type === 'test:old-type')).toBe(true)
+  await suite.client.planning().close()
+})

package/tests/lifecycle-feeds.spec.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'bun:test'
+import { CommitState, PLANNING_COMMIT_EVENT, TransitionAction } from '@owlmeans/planning'
+import type { Connection } from '@owlmeans/socket'
+import { makePlanningFeed, makePlanningResourceFeed } from '../src/index.js'
+import { makeSuite, protocols, tick } from './context.js'
+import { makeBarrier } from './lifecycle/context.js'
+
+describe('@owlmeans/client-planning — feed boundaries', () => {
+  test('stops both feed kinds without waiting for an unresolved seed, preserving fresh organization rows', async () => {
+    for (const kind of ['cards', 'teams'] as const) {
+      let identity = 'organization-a'
+      const pause = makeBarrier()
+      const suite = await makeSuite({ schemas: false, resources: true, entityId: () => identity, scopeKey: () => identity,
+        after: async call => { if (kind === 'cards' ? call.alias === protocols.card.list.alias : call.alias.endsWith(':teams:list')) await pause.hold() },
+      })
+      await suite.project()
+      await suite.local.teams.create({ name: 'Old team', fields: {} })
+      let notifications = 0
+      const feed = kind === 'cards'
+        ? makePlanningFeed(suite.client, { onChange: () => { notifications++ } })
+        : makePlanningResourceFeed(suite.client, { teams: { size: 0 }, refresh: 0, onChange: () => { notifications++ } })
+      await pause.entered
+      await suite.client.planning().close()
+      await feed.ready
+      const count = notifications
+      identity = 'organization-b'
+      const fresh = await suite.planning.teams.create({ name: 'New organization', fields: {} })
+      pause.release(); await tick(10)
+      expect(notifications).toBe(count)
+      expect(feed.seeded).toBe(false)
+      expect((await suite.client.planningStores!().cards.list({}, { size: 0 })).items).toEqual([])
+      expect((await suite.client.planningStores!().teams.list({}, { size: 0 })).items.map(team => team.id)).toEqual([fresh.id])
+      await suite.client.planning().close()
+    }
+  })
+
+  test('drains admitted authoritative deletions before clearing and rejects an old queued reconcile', async () => {
+    const suite = await makeSuite({ schemas: false })
+    const project = await suite.project()
+    const card = await suite.story(project.id!)
+    const stores = suite.client.planningStores!()
+    const feed = makePlanningFeed(suite.client, { query: { parent: project.id } })
+    await feed.ready
+    await suite.local.execute({ action: TransitionAction.Delete, card: card.id! }, { wait: true })
+    const pause = makeBarrier()
+    const purge = stores.cards.purge.bind(stores.cards)
+    stores.cards.purge = async (...args) => { await pause.hold(); return await purge(...args) }
+    const refreshing = feed.refresh()
+    await pause.entered
+    const queued = feed.refresh()
+    let stopped = false
+    const closing = suite.client.planning().close().then(() => { stopped = true })
+    await tick()
+    expect(stopped).toBe(false)
+    pause.release()
+    await Promise.all([closing, refreshing, queued])
+    stores.cards.purge = purge
+    expect((await stores.cards.list({}, { size: 0 })).items).toEqual([])
+    const fresh = await suite.planning.cards.get(project.id!)
+    await stores.cards.save(fresh)
+    await feed.refresh()
+    expect(await stores.cards.load(project.id!)).not.toBeNull()
+    await suite.client.planning().close()
+  })
+
+  test('a recordless socket frame never holds the mutation queue over its card RPC', async () => {
+    const pause = makeBarrier()
+    let delay = false
+    let carrier: Connection | undefined
+    const suite = await makeSuite({ schemas: false, socket: true, opening: async connection => { carrier = connection },
+      after: async call => { if (delay && call.alias === protocols.card.get.alias) await pause.hold() },
+    })
+    const project = await suite.project()
+    const card = await suite.story(project.id!)
+    const feed = makePlanningFeed(suite.client, { query: { parent: project.id } })
+    await feed.ready
+    await suite.local.execute({ action: TransitionAction.Update, card: card.id!, changes: { title: 'Updated on server' } }, { wait: true })
+    await tick()
+    const wire = structuredClone(suite.frames.find((frame: any) => frame.event === PLANNING_COMMIT_EVENT && frame.payload?.card === card.id && frame.payload.state === CommitState.Committed)) as { payload: { record?: unknown } }
+    expect(wire).toBeDefined()
+    delete wire.payload.record
+    delay = true
+    const receiving = carrier!.receive(JSON.stringify(wire))
+    await pause.entered
+    await suite.client.planning().close()
+    await receiving
+    pause.release(); await tick()
+    expect((await suite.client.planningStores!().cards.list({}, { size: 0 })).items).toEqual([])
+    expect((await suite.client.planningStores!().commits.list({}, { size: 0 })).items).toEqual([])
+    await feed.stop()
+  })
+})

package/tests/lifecycle-sockets.spec.ts

@@ -0,0 +1,76 @@
+import { describe, expect, test } from 'bun:test'
+import { makeSuite, tick } from './context.js'
+import { makeBarrier } from './lifecycle/context.js'
+
+describe('@owlmeans/client-planning — socket generations', () => {
+  test('closes a late carrier and never restores its old subscription over a fresh connection', async () => {
+    const pause = makeBarrier()
+    let staleCloses = 0
+    const suite = await makeSuite({ schemas: false, socket: true, opening: async (connection, attempt) => {
+      if (attempt !== 1) return
+      const close = connection.close.bind(connection)
+      connection.close = async () => { staleCloses++; await close() }
+      await pause.hold()
+    } })
+    const source = suite.client.planning().commits
+    let oldCalls = 0, newCalls = 0
+    const old = source.subscribe(() => { oldCalls++ })
+    void Promise.resolve(old).catch(() => {})
+    await pause.entered
+    await source.close()
+    await expect(Promise.resolve(old)).rejects.toThrow('scope-changed')
+    const stop = await source.subscribe(() => { newCalls++ })
+    pause.release(); await tick(10)
+    expect(staleCloses).toBe(1)
+    expect(source.connected()).toBe(true)
+    await suite.project()
+    await tick(10)
+    expect(oldCalls).toBe(0)
+    expect(newCalls).toBeGreaterThan(0)
+    stop(); await suite.client.planning().close()
+  })
+
+  test('a stale opener failure cannot discard a new pending opener or duplicate its connection', async () => {
+    const oldPause = makeBarrier(), newPause = makeBarrier()
+    const suite = await makeSuite({ schemas: false, socket: true, opening: async (_connection, attempt) => {
+      if (attempt === 1) { await oldPause.hold(); throw new Error('Old carrier failed') }
+      if (attempt === 2) await newPause.hold()
+    } })
+    const source = suite.client.planning().commits
+    const old = source.subscribe(() => {})
+    void Promise.resolve(old).catch(() => {})
+    await oldPause.entered; await source.close()
+    await expect(Promise.resolve(old)).rejects.toThrow('scope-changed')
+    const next = source.subscribe(() => {})
+    await newPause.entered
+    oldPause.release(); await tick()
+    const joined = source.subscribe(() => {})
+    await tick()
+    expect(suite.sockets()).toBe(2)
+    newPause.release()
+    const stops = await Promise.all([next, joined])
+    expect(source.connected()).toBe(true)
+    stops.forEach(stop => stop())
+    await suite.client.planning().close()
+  })
+
+  test('close cancels an in-progress dispatch snapshot before it invokes another old listener', async () => {
+    const pause = makeBarrier()
+    const suite = await makeSuite({ schemas: false, socket: true })
+    const source = suite.client.planning().commits
+    let later = 0
+    await source.subscribe(async () => await pause.hold())
+    await source.subscribe(() => { later++ })
+    const writing = suite.project()
+    await pause.entered
+    await source.close()
+    pause.release(); await writing; await tick()
+    expect(later).toBe(0)
+    let fresh = 0
+    const stop = await source.subscribe(() => { fresh++ })
+    await suite.project('Fresh connection'); await tick()
+    expect(fresh).toBeGreaterThan(0)
+    expect(later).toBe(0)
+    stop(); await suite.client.planning().close()
+  })
+})

package/tests/replies.spec.ts

@@ -0,0 +1,81 @@
+import { expect, test } from 'bun:test'
+import { AssigneeKind, mentionHelper, TransitionAction, WorkcardKind } from '@owlmeans/planning'
+import { ENTITY_ID, makeSuite, STORY_FLOW } from './context.js'
+
+test('stock HTTP and socket replies omit storage organization metadata and preserve usable client records', async () => {
+  const suite = await makeSuite({ resources: true, socket: true })
+  const p = suite.planning
+  const unsubscribe = await p.commits.subscribe(() => {})
+  const project = await suite.project()
+  const fields = { scope: { entityId: 'custom-field-value' }, card: { entityId: 'opaque-field-value' } }
+  const created = await p.execute({ action: TransitionAction.Create,
+    card: { kind: WorkcardKind.Project, type: project.type, title: 'Remote project', fields },
+  }, { wait: true })
+  expect(created.card?.entityId).toBe('')
+  expect(created.transition.entityId).toBe('')
+  expect(created.card?.fields).toEqual(fields)
+  expect((await suite.local.cards.get(created.card!.id!)).entityId).toBe(ENTITY_ID)
+  const card = await suite.story(project.id!)
+  await p.cards.get(card.id!)
+  await p.cards.list({ size: 0 })
+  await p.transitions.get(created.transition.id!)
+  await p.transitions.list({ card: created.card!.id! })
+  await p.commits.status(created.transition.id!)
+  const model = await p.model(project.id!)
+  await model.write('brief', '# Saved', { wait: true })
+  const specification = await p.specifications.current(project.id!, 'brief')
+  await p.specifications.get(specification!.id!)
+  await p.specifications.list(project.id!)
+  await p.specifications.revisions(specification!.id!)
+  const actor = await p.assignees.create({ nickname: 'wire-reader', kind: AssigneeKind.Human,
+    type: 'test:participant', authentication: { provider: 'external', externalId: 'subject' } })
+  const team = await p.teams.create({ name: 'Wire team' })
+  await p.teams.addMember(team.id!, actor.id!)
+  await p.teams.attach(team.id!, project.id!)
+  for (const name of ['assignees', 'teams'] as const) {
+    const id = name === 'assignees' ? actor.id! : team.id!
+    await p[name].get(id)
+    await p[name].list()
+  }
+  expect((await p.teams.members(team.id!))[0]?.entityId).toBe('')
+  expect((await p.teams.assignees(project.id!))[0]?.id).toBe(actor.id)
+  expect(await p.teams.projects(team.id!)).toEqual([project.id!])
+  const comment = await p.comments.create({ card: card.id!, body: mentionHelper.encode(actor.id!, actor.nickname) })
+  await p.comments.get(comment.id!)
+  await p.comments.list()
+  const mentions = await p.mentions.list()
+  await p.mentions.get(mentions.items[0]!.id!)
+  await p.mentions.rebuild(comment.id!)
+  await p.relationships.list()
+  const definitions = await p.definitions!.define({ types: [{ type: 'test:wire', kind: WorkcardKind.Card,
+    version: 1, fields: { type: 'object', properties: { scope: { type: 'object', properties: { entityId: { type: 'string' } } } } },
+    flows: [STORY_FLOW], specifications: [],
+  }] }, { project: project.id })
+  expect(definitions[0]?.entityId).toBe('')
+  expect((await p.definitions!.bundle(project.id)).scope?.entityId).toBe('')
+
+  // Check the actual server responses before the client hydrates its advisory metadata.
+  for (const call of suite.calls) {
+    expect(JSON.stringify(call.reply) ?? '').not.toContain(ENTITY_ID)
+    const check = (value: unknown): void => {
+      if (Array.isArray(value)) { value.forEach(check); return }
+      if (value == null || typeof value !== 'object') return
+      const object = value as Record<string, unknown>
+      expect(object).not.toHaveProperty('entityId')
+      for (const key of ['items', 'records', 'card', 'record', 'transition', 'bundle', 'scope']) check(object[key])
+    }
+    check(call.reply)
+  }
+  const frames = suite.frames as Array<{ payload?: Record<string, unknown> }>
+  const commitFrames = frames.filter(frame => frame.payload?.transition != null)
+  expect(commitFrames.length).toBeGreaterThan(0)
+  for (const frame of commitFrames) {
+    expect(JSON.stringify(frame)).not.toContain(ENTITY_ID)
+    expect(frame.payload).not.toHaveProperty('entityId')
+    if (frame.payload?.record != null) expect(frame.payload.record).not.toHaveProperty('entityId')
+  }
+  expect((await suite.client.planningStores!().assignees.get(actor.id!)).entityId).toBe('')
+  expect((await suite.local.assignees.get(actor.id!)).entityId).toBe(ENTITY_ID)
+  unsubscribe()
+  await suite.client.planning().close()
+})

package/tests/resources.spec.ts

@@ -0,0 +1,116 @@
+import { describe, expect, test } from 'bun:test'
+import { AssigneeKind, mentionHelper, WorkcardConflict } from '@owlmeans/planning'
+import { makePlanningResourceFeed } from '../src/index.js'
+import { ENTITY_ID, makeSuite } from './context.js'
+
+describe('@owlmeans/client-planning — separate resources over real protocol handlers', () => {
+  test('active assignee feeds include unset flags and reconcile removal without dropping retired history', async () => {
+    const suite = await makeSuite({ resources: true })
+    const draft = (nickname: string) => ({ nickname, kind: AssigneeKind.Human, type: 'test:participant', authentication: { provider: 'external', externalId: nickname } })
+    const active = await suite.local.assignees.create(draft('active'))
+    const removed = await suite.local.assignees.create(draft('removed'))
+    const retired = await suite.local.assignees.create(draft('retired'))
+    await suite.local.assignees.retire(retired.id!, { version: 1 })
+    await suite.planning.assignees.get(retired.id!)
+    const stores = suite.client.planningStores!()
+    const ids = [active.id!, removed.id!, retired.id!]
+    const feed = makePlanningResourceFeed(suite.client, { assignees: { ids, retired: false, size: 0 }, refresh: 0 })
+    await feed.ready
+    expect(feed.error).toBeNull()
+    expect((await suite.planning.assignees.list({ ids, retired: false })).items.map(row => row.id).sort()).toEqual([active.id!, removed.id!].sort())
+    expect(await stores.assignees.load(active.id!)).not.toBeNull()
+    expect(await stores.assignees.load(removed.id!)).not.toBeNull()
+    // A remote retirement removes the formerly-active snapshot, but unrelated historical
+    // identities already in the shared mirror remain available for existing references.
+    await suite.local.assignees.retire(removed.id!, { version: 1 })
+    await feed.refresh()
+    expect(await stores.assignees.load(removed.id!)).toBeNull()
+    expect((await stores.assignees.get(retired.id!)).retired).toBe(true)
+    expect(await stores.assignees.load(active.id!)).not.toBeNull()
+    await feed.stop(); await suite.client.planning().close()
+  })
+
+  test('assignees, teams, comments and mentions roundtrip and mirror versioned writes', async () => {
+    const suite = await makeSuite({ resources: true })
+    const p = suite.planning, project = await suite.project(), card = await suite.story(project.id!)
+    const actor = await p.assignees.create({ nickname: 'reader', kind: AssigneeKind.Human, type: 'test:participant', authentication: { provider: 'external', externalId: 'reader-id' } })
+    const renamed = await p.assignees.update(actor.id!, { nickname: 'renamed' }, { version: 1 })
+    expect(renamed.id).toBe(actor.id)
+    await expect(p.assignees.update(actor.id!, { nickname: 'stale' }, { version: 1 })).rejects.toBeInstanceOf(WorkcardConflict)
+    const team = await p.teams.create({ name: 'Editors', externalId: 'external:group' })
+    await p.teams.addMember(team.id!, actor.id!); await p.teams.attach(team.id!, project.id!)
+    expect((await p.teams.assignees(project.id!)).map(row => row.id)).toEqual([actor.id])
+    const comment = await p.comments.create({ card: card.id!, body: mentionHelper.encode(actor.id!, actor.nickname) })
+    expect(comment.author).toBe(suite.local.scope.assigneeId!)
+    const mentions = await p.mentions.list({ comment: comment.id })
+    expect(mentions.items.map(row => row.assignee)).toEqual([actor.id!])
+    expect((await p.mentions.get(mentions.items[0].id!)).revision).toBe(1)
+    await p.comments.update(comment.id!, { body: 'no mentions' }, { version: 1 })
+    expect(await p.mentions.load(mentions.items[0].id!)).toBeNull()
+    const stores = suite.client.planningStores!()
+    expect((await stores.assignees.get(actor.id!)).version).toBe(2)
+    expect((await stores.comments.get(comment.id!)).version).toBe(2)
+    await p.comments.remove(comment.id!, { version: 2 })
+    expect(await stores.comments.load(comment.id!)).toBeNull()
+    const query = suite.calls.find(call => call.alias.endsWith(':mentions:list'))?.query
+    expect(typeof query?.query).toBe('string')
+    await suite.client.planning().close()
+  })
+
+  test('a delayed seed retains a local version written after the snapshot began', async () => {
+    let release: (() => void) | undefined, entered: (() => void) | undefined
+    const arrived = new Promise<void>(resolve => { entered = resolve })
+    const held = new Promise<void>(resolve => { release = resolve })
+    let delay = false
+    const suite = await makeSuite({ resources: true, after: async call => {
+      if (delay && call.alias.endsWith(':teams:list')) { delay = false; entered!(); await held }
+    } })
+    const p = suite.planning, stores = suite.client.planningStores!()
+    const team = await p.teams.create({ name: 'Before' })
+    delay = true
+    const feed = makePlanningResourceFeed(suite.client, { scope: { entityId: ENTITY_ID }, teams: { size: 0 }, refresh: 0 })
+    await arrived
+    await p.teams.update(team.id!, { name: 'After' }, { version: 1 })
+    const added = await p.teams.create({ name: 'New during seed' })
+    release!(); await feed.ready
+    expect((await stores.teams.get(team.id!)).name).toBe('After')
+    expect((await stores.teams.get(added.id!)).name).toBe('New during seed')
+    await feed.stop(); await suite.client.planning().close()
+  })
+
+  test('scope changes reject stale reads and close clears registered feeds and mirrors', async () => {
+    let identity = 'old-session', release: (() => void) | undefined, entered: (() => void) | undefined
+    const held = new Promise<void>(resolve => { release = resolve }), arrived = new Promise<void>(resolve => { entered = resolve })
+    let delay = false
+    const suite = await makeSuite({ resources: true, scopeKey: () => identity, after: async call => {
+      if (delay && call.alias.endsWith(':teams:get')) { delay = false; entered!(); await held }
+    } })
+    const team = await suite.local.teams.create({ name: 'Old identity' })
+    delay = true
+    const reading = suite.planning.teams.get(team.id!)
+    await arrived; identity = 'new-session'; release!()
+    await expect(reading).rejects.toThrow('scope-changed')
+    expect(await suite.client.planningStores!().teams.load(team.id!)).toBeNull()
+    const feed = makePlanningResourceFeed(suite.client, { teams: { size: 0 }, refresh: 0 })
+    await feed.ready
+    expect(await suite.client.planningStores!().teams.load(team.id!)).not.toBeNull()
+    await suite.client.planning().close()
+    expect(await suite.client.planningStores!().teams.load(team.id!)).toBeNull()
+    await feed.refresh()
+    expect(await suite.client.planningStores!().teams.load(team.id!)).toBeNull()
+  })
+
+  test('stopping an in-flight resource feed prevents old tenant results from publishing', async () => {
+    let release: (() => void) | undefined, entered: (() => void) | undefined
+    const held = new Promise<void>(resolve => { release = resolve }), arrived = new Promise<void>(resolve => { entered = resolve })
+    const suite = await makeSuite({ resources: true, after: async call => {
+      if (call.alias.endsWith(':teams:list')) { entered!(); await held }
+    } })
+    const team = await suite.local.teams.create({ name: 'Old organization' })
+    const feed = makePlanningResourceFeed(suite.client, { teams: { size: 0 }, refresh: 0 })
+    await arrived
+    const stopping = feed.stop(); release!(); await stopping
+    expect(await suite.client.planningStores!().teams.load(team.id!)).toBeNull()
+    await suite.client.planning().close()
+  })
+})

package/tests/stores.spec.ts

@@ -1,20 +1,21 @@
 import { describe, expect, test } from 'bun:test'
-import { isPending, modelOf, TransitionAction, WorkcardKind } from '@owlmeans/planning'
-import { applyCards, syncCards } from '../src/index.js'
+import { cardHelper, modelOf, TransitionAction, WorkcardKind } from '@owlmeans/planning'
+import { planningMirrorOf, syncHelper } from '../src/index.js'
 import { makeSuite } from './context.js'
 
 describe('@owlmeans/client-planning — the state mirror', () => {
   test('syncCards drops only what matches `where` and the list does not name', async () => {
     const suite = await makeSuite()
     const stores = suite.client.planningStores!()
+    const mirror = planningMirrorOf(stores)
     const one = await suite.project('One')
     const two = await suite.project('Two')
     const kept = await suite.story(one.id!, 'Kept')
     const deleted = await suite.story(one.id!, 'Deleted elsewhere')
     const elsewhere = await suite.story(two.id!, 'Another project')
-    await applyCards(stores, [one, two, kept, deleted, elsewhere])
+    await mirror.applyCards([one, two, kept, deleted, elsewhere])
 
-    await syncCards(stores.cards, [kept], { parent: one.id })
+    await syncHelper.syncCards(stores.cards, [kept], { parent: one.id })
 
     const ids = (await stores.cards.list()).items.map(card => card.id).sort()
     expect(ids).toEqual([one.id, two.id, kept.id, elsewhere.id].sort())
@@ -32,11 +33,11 @@ describe('@owlmeans/client-planning — the state mirror', () => {
       suite.planning.specifications.list(project.id!),
       suite.planning.cards.list({ kind: WorkcardKind.Card, parent: project.id }),
     ])
-    await syncCards(stores.cards, projects.items, { kind: WorkcardKind.Project })
-    await syncCards(stores.cards, specs.items, { kind: WorkcardKind.Specification, parent: project.id })
+    await syncHelper.syncCards(stores.cards, projects.items, { kind: WorkcardKind.Project })
+    await syncHelper.syncCards(stores.cards, specs.items, { kind: WorkcardKind.Specification, parent: project.id })
     // A card list reloading with nothing in it must not take the project or its brief with it.
-    await syncCards(stores.cards, [], { kind: WorkcardKind.Card, parent: project.id })
-    await syncCards(stores.cards, cards.items, { kind: WorkcardKind.Card, parent: project.id })
+    await syncHelper.syncCards(stores.cards, [], { kind: WorkcardKind.Card, parent: project.id })
+    await syncHelper.syncCards(stores.cards, cards.items, { kind: WorkcardKind.Card, parent: project.id })
 
     const kinds = (await stores.cards.list()).items.map(card => card.kind).sort()
     expect(kinds).toEqual([WorkcardKind.Card, WorkcardKind.Project, WorkcardKind.Specification])
@@ -45,23 +46,24 @@ describe('@owlmeans/client-planning — the state mirror', () => {
   test('a receipt marks the card pending (head > seq) and its commit clears the mark', async () => {
     const suite = await makeSuite({ sync: false })
     const stores = suite.client.planningStores!()
+    const mirror = planningMirrorOf(stores)
     const project = await suite.project()
     const story = await suite.story(project.id!)
-    await applyCards(stores, [story])
+    await mirror.applyCards([story])
 
     const receipt = await suite.planning.execute({
       card: story.id!, action: TransitionAction.Transit, transition: 'start', expectSeq: story.seq,
     })
 
     const marked = await stores.cards.get(story.id!)
-    expect(isPending(marked)).toBe(true)
+    expect(cardHelper.isPending(marked)).toBe(true)
     expect(modelOf(marked, suite.planning).pending()).toBe(true)
 
     await suite.store.flush()
     await receipt.committed({ timeout: 5_000 })
 
     const folded = await stores.cards.get(story.id!)
-    expect(isPending(folded)).toBe(false)
+    expect(cardHelper.isPending(folded)).toBe(false)
     expect(folded.status).toBe('doing')
   })
 })