@owlmeans/client-planning 0.1.18-rc.21 → 0.1.18-rc.22

package/src/utils/record.ts

@@ -2,94 +2,87 @@ import type { PlanningCommitRecord, PlanningStores } from '../types.js'
 import type { CommitState, Relationship, Workcard } from '@owlmeans/planning'
 import type { ResourceRecord } from '@owlmeans/resource'
 import type { StateResource } from '@owlmeans/state'
+import type { RecordUtils } from './record/types.js'
 
-const stable = (value: unknown): unknown => {
-  if (Array.isArray(value)) {
-    return value.map(stable)
-  }
-  if (value != null && typeof value === 'object') {
-    return Object.fromEntries(Object.entries(value as Record<string, unknown>)
-      .filter(([, entry]) => entry !== undefined)
-      .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
-      .map(([key, entry]) => [key, stable(entry)]))
+export const createRecordUtils = (): RecordUtils => {
+  const stable = (value: unknown): unknown => {
+    if (Array.isArray(value)) {
+      return value.map(stable)
+    }
+    if (value != null && typeof value === 'object') {
+      return Object.fromEntries(Object.entries(value as Record<string, unknown>)
+        .filter(([, entry]) => entry !== undefined)
+        .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+        .map(([key, entry]) => [key, stable(entry)]))
+    }
+
+    return value
   }
 
-  return value
-}
+  const sameRecord = (left: unknown, right: unknown): boolean =>
+    JSON.stringify(stable(left)) === JSON.stringify(stable(right))
 
-/** Same content, whatever order the keys arrived in. */
-const sameRecord = (left: unknown, right: unknown): boolean =>
-  JSON.stringify(stable(left)) === JSON.stringify(stable(right))
+  const putCard = async (store: StateResource<Workcard>, card: Workcard): Promise<Workcard> => {
+    if (card.id == null) {
+      return card
+    }
+    const known = await store.load(card.id)
+    if (known != null && (known.seq ?? 0) > (card.seq ?? 0)) {
+      return known
+    }
+    const head = Math.max(card.head ?? card.seq ?? 0, known?.head ?? 0)
+    const next = head > (card.head ?? card.seq ?? 0) ? { ...card, head } : card
+    if (known != null && sameRecord(known, next)) {
+      return known
+    }
+    await store.save(next)
 
-/**
- * Write one card unless the store already holds a NEWER fold of it.
- *
- * `seq` is the last folded transition, so a lower one is an older picture — a list fetched before a
- * commit landed must not undo that commit. The head only ever grows: a head this client allocated
- * (`applyReceipt`) stays until a fold catches up with it.
- */
-const putCard = async (store: StateResource<Workcard>, card: Workcard): Promise<Workcard> => {
-  if (card.id == null) {
-    return card
-  }
-  const known = await store.load(card.id)
-  if (known != null && (known.seq ?? 0) > (card.seq ?? 0)) {
-    return known
+    return next
   }
-  const head = Math.max(card.head ?? card.seq ?? 0, known?.head ?? 0)
-  const next = head > (card.head ?? card.seq ?? 0) ? { ...card, head } : card
-  if (known != null && sameRecord(known, next)) {
-    return known
-  }
-  await store.save(next)
-
-  return next
-}
 
-const putLink = async (store: StateResource<Relationship>, link: Relationship): Promise<void> => {
-  if (link.id == null) {
-    return
-  }
-  const known = await store.load(link.id)
-  if (known != null && sameRecord(known, link)) {
-    return
+  const putLink = async (store: StateResource<Relationship>, link: Relationship): Promise<void> => {
+    if (link.id == null) {
+      return
+    }
+    const known = await store.load(link.id)
+    if (known != null && sameRecord(known, link)) {
+      return
+    }
+    await store.save(link)
   }
-  await store.save(link)
-}
 
-/** Drop a card, whatever lives under it when it is a project, and every link touching any of them. */
-const dropCard = async (stores: PlanningStores, id: string, project: boolean): Promise<void> => {
-  const ids = [id]
-  if (project) {
-    const children = await stores.cards.list({ parents: { $contains: [id] } })
-    ids.push(...children.items.map(child => child.id).filter((child): child is string => child != null))
-  }
-  await stores.cards.purge({ id: { $in: ids } })
-  if (await stores.links.count({ $or: [{ from: { $in: ids } }, { to: { $in: ids } }] }) > 0) {
-    await stores.links.purge({ $or: [{ from: { $in: ids } }, { to: { $in: ids } }] })
+  const dropCard = async (stores: PlanningStores, id: string, project: boolean): Promise<void> => {
+    const ids = [id]
+    if (project) {
+      const children = await stores.cards.list({ parents: { $contains: [id] } })
+      ids.push(...children.items.map(child => child.id).filter((child): child is string => child != null))
+    }
+    await stores.cards.purge({ id: { $in: ids } })
+    if (await stores.links.count({ $or: [{ from: { $in: ids } }, { to: { $in: ids } }] }) > 0) {
+      await stores.links.purge({ $or: [{ from: { $in: ids } }, { to: { $in: ids } }] })
+    }
   }
-}
 
-/** Record what is known about a transition, merged over what was known before. */
-const putCommit = async (
-  store: StateResource<PlanningCommitRecord>, record: Partial<PlanningCommitRecord> & { id: string, state: CommitState }
-): Promise<PlanningCommitRecord> => {
-  const known = await store.load(record.id)
-  const next = { ...known, ...clean(record) } as PlanningCommitRecord
-  if (known != null && sameRecord(known, next)) {
-    return known
-  }
-  await store.save(next)
+  const putCommit = async (
+    store: StateResource<PlanningCommitRecord>, record: Partial<PlanningCommitRecord> & { id: string, state: CommitState }
+  ): Promise<PlanningCommitRecord> => {
+    const known = await store.load(record.id)
+    const next = { ...known, ...clean(record) } as PlanningCommitRecord
+    if (known != null && sameRecord(known, next)) {
+      return known
+    }
+    await store.save(next)
 
-  return next
-}
+    return next
+  }
 
-const clean = <T extends object>(record: T): T =>
-  Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)) as T
+  const clean = <T extends object>(record: T): T =>
+    Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)) as T
 
-const idsOf = <T extends ResourceRecord>(records: T[]): string[] =>
-  records.map(record => record.id).filter((id): id is string => id != null)
+  const idsOf = <T extends ResourceRecord>(records: T[]): string[] =>
+    records.map(record => record.id).filter((id): id is string => id != null)
 
-export const createRecordHelper = () => ({ sameRecord, putCard, putLink, dropCard, putCommit, clean, idsOf })
+  return { sameRecord, putCard, putLink, dropCard, putCommit, clean, idsOf }
+}
 
-export const recordHelper = createRecordHelper()
+export const recordUtils = createRecordUtils()

package/tests/events.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from 'bun:test'
 import { CommitState, TransitionAction, WorkcardKind } from '@owlmeans/planning'
 import type { CommitEvent, Transition, Workcard } from '@owlmeans/planning'
-import { applyCards, applyCommitEvent, syncLinks } from '../src/index.js'
+import { planningMirrorOf, syncHelper } from '../src/index.js'
 import { STORY, makeSuite } from './context.js'
 
 /** The frame a bus publishes for a transition — ids only unless a record is given. */
@@ -23,13 +23,14 @@ describe('@owlmeans/client-planning — commit folds', () => {
   test('a committed frame without a record writes the card re-read through the facade', async () => {
     const suite = await makeSuite()
     const stores = suite.client.planningStores!()
+    const mirror = planningMirrorOf(stores)
     const project = await suite.project()
     const receipt = await suite.local.execute({
       card: { kind: WorkcardKind.Card, type: STORY, parent: project.id, title: 'Folded' },
       action: TransitionAction.Create,
     }, { wait: true })
 
-    await applyCommitEvent(stores, frameOf(receipt.transition), suite.planning)
+    await mirror.applyCommitEvent(frameOf(receipt.transition), suite.planning)
 
     expect(await stores.cards.get(receipt.transition.card)).toEqual(receipt.card!)
     expect((await stores.commits.get(receipt.transition.id!)).state).toBe(CommitState.Committed)
@@ -38,6 +39,7 @@ describe('@owlmeans/client-planning — commit folds', () => {
   test('a committed delete removes the row and every link touching it', async () => {
     const suite = await makeSuite()
     const stores = suite.client.planningStores!()
+    const mirror = planningMirrorOf(stores)
     const project = await suite.project()
     const first = await suite.story(project.id!, 'First')
     const second = (await suite.local.execute({
@@ -45,13 +47,13 @@ describe('@owlmeans/client-planning — commit folds', () => {
       action: TransitionAction.Create,
       links: [{ type: 'follows', to: first.id! }],
     }, { wait: true })).card!
-    await applyCards(stores, [first, second])
+    await mirror.applyCards([first, second])
     const links = await suite.planning.relationships.list({ from: second.id })
-    await syncLinks(stores.links, links.items)
+    await syncHelper.syncLinks(stores.links, links.items)
     expect(await stores.links.count()).toBe(1)
 
     const removal = await suite.local.execute({ card: first.id!, action: TransitionAction.Delete }, { wait: true })
-    await applyCommitEvent(stores, frameOf(removal.transition, null), suite.planning)
+    await mirror.applyCommitEvent(frameOf(removal.transition, null), suite.planning)
 
     expect(await stores.cards.load(first.id!)).toBeNull()
     expect(await stores.cards.load(second.id!)).not.toBeNull()
@@ -61,6 +63,7 @@ describe('@owlmeans/client-planning — commit folds', () => {
   test('a frame for an id the store never saw still writes a row', async () => {
     const suite = await makeSuite()
     const stores = suite.client.planningStores!()
+    const mirror = planningMirrorOf(stores)
     const project = await suite.project()
     const receipt = await suite.local.execute({
       card: { kind: WorkcardKind.Card, type: STORY, parent: project.id, title: 'From another tab' },
@@ -68,7 +71,7 @@ describe('@owlmeans/client-planning — commit folds', () => {
     }, { wait: true })
     expect(await stores.cards.count()).toBe(0)
 
-    await applyCommitEvent(stores, frameOf(receipt.transition, receipt.card))
+    await mirror.applyCommitEvent(frameOf(receipt.transition, receipt.card))
 
     expect((await stores.cards.get(receipt.transition.card)).title).toBe('From another tab')
   })
@@ -76,6 +79,7 @@ describe('@owlmeans/client-planning — commit folds', () => {
   test('an older seq never overwrites a newer record', async () => {
     const suite = await makeSuite()
     const stores = suite.client.planningStores!()
+    const mirror = planningMirrorOf(stores)
     const project = await suite.project()
     const created = await suite.local.execute({
       card: { kind: WorkcardKind.Card, type: STORY, parent: project.id, title: 'Racing' },
@@ -84,9 +88,9 @@ describe('@owlmeans/client-planning — commit folds', () => {
     const started = await suite.local.execute({
       card: created.transition.card, action: TransitionAction.Transit, transition: 'start',
     }, { wait: true })
-    await applyCards(stores, [started.card!])
+    await mirror.applyCards([started.card!])
 
-    await applyCommitEvent(stores, frameOf(created.transition, created.card))
+    await mirror.applyCommitEvent(frameOf(created.transition, created.card))
 
     const stored = await stores.cards.get(created.transition.card)
     expect(stored.seq).toBe(2)

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')
   })
 })

package/build/utils/types.d.ts

@@ -1,3 +0,0 @@
-import type { createRecordHelper } from './record.js';
-export type RecordHelper = ReturnType<typeof createRecordHelper>;
-//# sourceMappingURL=types.d.ts.map

package/build/utils/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErD,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/build/utils.d.ts

@@ -1,13 +0,0 @@
-import { type StateAlias } from '@owlmeans/state';
-import type { Relationship, Workcard } from '@owlmeans/planning';
-import type { PlanningCommitRecord, PlanningStoreAliases } from './types.js';
-/**
- * The ONE card store. Projects, cards and specifications share an id space on the server, so they
- * share it here too — a store per kind would let a list reload of one kind drop another's rows.
- */
-export declare const CARDS: StateAlias<Workcard>;
-export declare const LINKS: StateAlias<Relationship>;
-/** What the client has learned about each transition it wrote or saw, keyed by transition id. */
-export declare const COMMITS: StateAlias<PlanningCommitRecord>;
-export declare const DEFAULT_STORE_ALIASES: Readonly<PlanningStoreAliases>;
-//# sourceMappingURL=utils.d.ts.map

package/build/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAc,MAAM,iBAAiB,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAE5E;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,UAAU,CAAC,QAAQ,CAA+C,CAAA;AAEtF,eAAO,MAAM,KAAK,EAAE,UAAU,CAAC,YAAY,CAAmD,CAAA;AAE9F,iGAAiG;AACjG,eAAO,MAAM,OAAO,EAAE,UAAU,CAAC,oBAAoB,CAA6D,CAAA;AAElH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,oBAAoB,CAI/D,CAAA"}

package/build/utils.js

@@ -1,15 +0,0 @@
-import { stateAlias } from '@owlmeans/state';
-/**
- * The ONE card store. Projects, cards and specifications share an id space on the server, so they
- * share it here too — a store per kind would let a list reload of one kind drop another's rows.
- */
-export const CARDS = stateAlias('planning-card-state');
-export const LINKS = stateAlias('planning-link-state');
-/** What the client has learned about each transition it wrote or saw, keyed by transition id. */
-export const COMMITS = stateAlias('planning-commit-state');
-export const DEFAULT_STORE_ALIASES = Object.freeze({
-    cards: CARDS,
-    links: LINKS,
-    commits: COMMITS,
-});
-//# sourceMappingURL=utils.js.map

package/build/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAI7D;;;GAGG;AACH,MAAM,CAAC,MAAM,KAAK,GAAyB,UAAU,CAAW,qBAAqB,CAAC,CAAA;AAEtF,MAAM,CAAC,MAAM,KAAK,GAA6B,UAAU,CAAe,qBAAqB,CAAC,CAAA;AAE9F,iGAAiG;AACjG,MAAM,CAAC,MAAM,OAAO,GAAqC,UAAU,CAAuB,uBAAuB,CAAC,CAAA;AAElH,MAAM,CAAC,MAAM,qBAAqB,GAAmC,MAAM,CAAC,MAAM,CAAC;IACjF,KAAK,EAAE,KAAK;IACZ,KAAK,EAAE,KAAK;IACZ,OAAO,EAAE,OAAO;CACjB,CAAC,CAAA"}

package/src/utils/types.ts

@@ -1,3 +0,0 @@
-import type { createRecordHelper } from './record.js'
-
-export type RecordHelper = ReturnType<typeof createRecordHelper>

package/src/utils.ts

@@ -1,20 +0,0 @@
-import { type StateAlias, stateAlias } from '@owlmeans/state'
-import type { Relationship, Workcard } from '@owlmeans/planning'
-import type { PlanningCommitRecord, PlanningStoreAliases } from './types.js'
-
-/**
- * The ONE card store. Projects, cards and specifications share an id space on the server, so they
- * share it here too — a store per kind would let a list reload of one kind drop another's rows.
- */
-export const CARDS: StateAlias<Workcard> = stateAlias<Workcard>('planning-card-state')
-
-export const LINKS: StateAlias<Relationship> = stateAlias<Relationship>('planning-link-state')
-
-/** What the client has learned about each transition it wrote or saw, keyed by transition id. */
-export const COMMITS: StateAlias<PlanningCommitRecord> = stateAlias<PlanningCommitRecord>('planning-commit-state')
-
-export const DEFAULT_STORE_ALIASES: Readonly<PlanningStoreAliases> = Object.freeze({
-  cards: CARDS,
-  links: LINKS,
-  commits: COMMITS,
-})